using HH.Redis.ReisModel;
using HH.WMS.BLL.Algorithm;
using HH.WMS.BLL.Basic;
using HH.WMS.BLL.External;
using HH.WMS.BLL.InStock;
using HH.WMS.BLL.MoveStock;
using HH.WMS.BLL.SysMgr;
using HH.WMS.Common;
using HH.WMS.Common.Algorithm;
using HH.WMS.Common.External;
using HH.WMS.Common.Para;
using HH.WMS.DAL;
using HH.WMS.DAL.Basic;
using HH.WMS.DAL.InStock;
using HH.WMS.DAL.Pda;
using HH.WMS.DAL.SysMgr;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Check;
using HH.WMS.Entitys.Dto;
using HH.WMS.Entitys.Entitys;
using HH.WMS.Entitys.External;
using HH.WMS.Entitys.MoveStock;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HH.WMS.BLL.Pda
{
    public class YuShouApiBLL : DapperBaseBLL
    {
        #region 上料确认（整托、部分）

        public OperateResult UpMaterialSure(string trayCode, string type, string uniqueCodes, LogPara logPara)
        {
            try
            {
                var trayItemMstList = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new { CN_S_TRAY_CODE = trayCode });
                var trayItemDtlList = type == "all"
                    ? BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().GetTrayItemDtlByTrayCode(trayCode)
                    : DALCreator.Create<TN_WM_B_TRAY_ITEM_RELDAL>().GetDtlByUniques(uniqueCodes);
                var trayLocaiton = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_LOCATIONEntity>>().GetSingleEntity(new { CN_S_TRAY_CODE = trayCode });

                var transResult = UseTransaction(trans =>
                {
                    //删除托盘货位关联
                    var result = DALCreator.Create<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new { CN_S_TRAY_CODE = trayCode }, trans);
                    Log.Detail(logPara, "删除托盘货位关联结果：" + (result.Success ? "成功!" : ("失败" + result.Msg)));
                    if (!result.Success) return;

                    //删除料箱托盘关联
                    if (type.Equals("all"))
                    {
                        //删除托盘产品关联主表、子表
                        result = BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().Delete(" CN_S_TRAY_CODE='" + trayCode + "' ", trans, logPara);
                        if (!result.Success) return;

                        //修改托盘状态为空
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_INFOEntity>>().Update(new
                        {
                            CN_S_USE_STATE = "空"
                        }, new
                        {
                            CN_S_TRAY_CODE = trayCode
                        }, trans);
                        Log.Detail(logPara, "修改托盘状态为空！");
                    }
                    else if (type.Equals("part"))
                    {
                        var useState = "空";

                        foreach (var trayItemMst in trayItemMstList)
                        {
                            var curTrayItemDtls = trayItemDtlList.Where(e => e.CN_PARENT_GUID.Equals(trayItemMst.CN_GUID));
                            if (curTrayItemDtls.Count() > 0)
                            {
                                trayItemMst.CN_F_QUANTITY -= curTrayItemDtls.Count();
                                if (trayItemMst.CN_F_QUANTITY > 0)
                                {
                                    useState = "不满";
                                    result = DALCreator.Create<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().Update(new { trayItemMst.CN_F_QUANTITY }, new { CN_GUID = trayItemMst.CN_GUID }, trans);
                                }
                                else
                                {
                                    result = DALCreator.Create<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().Delete(new { CN_GUID = trayItemMst.CN_GUID }, trans);
                                }
                                Log.Detail(logPara, "主表" + trayItemMst.CN_GUID + "降量结果：" + (result.Success ? "成功!" : ("失败" + result.Msg)));
                            }
                        }

                        foreach (var trayItemDtl in trayItemDtlList)
                        {
                            //删除托盘物料关联子表
                            result = DALCreator.Create<DapperDAL<TN_WM_B_TRAY_ITEM_DTLEntity>>().Delete(new { CN_GUID = trayItemDtl.CN_GUID }, trans);
                            Log.Detail(logPara, "删除托盘物料关联子表结果：" + (result.Success ? "成功!" : ("失败" + result.Msg)));
                            if (!result.Success) return;
                        }

                        //修改托盘状态为空
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_INFOEntity>>().Update(new
                        {
                            CN_S_USE_STATE = useState
                        }, new
                        {
                            CN_S_TRAY_CODE = trayCode
                        }, trans);
                    }

                    //修改货位扩展表
                    result = CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(
                        new { CN_S_USE_STATE = "空" },
                        new { CN_S_LOCATION_CODE = trayLocaiton.CN_S_LOCATION_CODE }
                        , trans);

                    //result = BLLCreator.Create<TN_WM_LOCATION_EXTBLL>().UpdateLocationExtState(trayLocaiton.CN_S_LOCATION_CODE, "空", "", "", trans);
                    Log.Detail(logPara, "货位扩展表的状态置为空结果：" + JsonConvert.SerializeObject(result));
                });

                if (transResult.Success)
                {
                    foreach (var trayItemDtl in trayItemDtlList)
                    {
                        //更新BARCODE表使用状态
                        var resultCur = BLLCreator.Create<MONGO_PRINT_BARCODEBLL>().UpdateUpMetarialState(trayItemDtl.CN_S_UNIQUE_CODE, "N");
                        Log.Detail(logPara, "唯一码：" + trayItemDtl.CN_S_UNIQUE_CODE + "，更新BARCODE表使用状态结果：" + (resultCur ? "成功!" : "失败"));
                    }
                }
                return transResult;
            }
            catch (Exception ex)
            {
                Log.Detail(logPara, "上料失败！" + ex.Message);
                return new OperateResult { Success = false, Msg = ex.Message };
            }
        }

        #endregion

        #region 移库保存

        public OperateResult SaveMoveStock(SaveMoveStockDto saveMoveStockDto, LogPara logPara, RedisUserEntity user)
        {
            var moveStockTask = new TN_WM_MOVE_STOCK_TASK_MSTEntity
            {
                CN_GUID = Guid.NewGuid().ToString(),
                CN_S_START_AREA = saveMoveStockDto.StartAreaCode,
                CN_S_END_AREA = saveMoveStockDto.EndAreaCode,
                CN_S_STATE = "未执行",
                CN_F_QUANTITY = Convert.ToDecimal(saveMoveStockDto.ItemQty),
                CN_F_MOVE_QUANTITY = 0,
                CN_S_RESULT = "",
                CN_S_ITEM_CODE = saveMoveStockDto.ItemCode,
                CN_S_STOCK_CODE = saveMoveStockDto.StockCode,
                CN_T_MODIFY = DateTime.Now,
                CN_T_CREATE = DateTime.Now,
                CN_S_CREATOR = user.CN_S_LOGIN,
                CN_S_CREATOR_BY = user.CN_S_NAME,
                CN_S_LOT_NO = saveMoveStockDto.LotNo
            };
            Log.Detail(logPara, LogDescribe.Content(moveStockTask));
            return BLLCreator.Create<MoveStockTaskBLL>().AddMst(moveStockTask, null);

            //#region 起点货位
            //List<areaPriorClass> lstArea = new List<areaPriorClass>();
            //areaPriorClass areaClass = new areaPriorClass();
            //areaClass.areaCode = saveMoveStockDto.StartAreaCode;
            //areaClass.Prior = 1;
            //lstArea.Add(areaClass);
            ////调用入库算法，获取货位
            //OutAssignEnitty oAe = new OutAssignEnitty()
            //{
            //    projectCode = "ys001",
            //    lstAreaPrior = lstArea,
            //    stockCode = saveMoveStockDto.StockCode,
            //    itemCode = saveMoveStockDto.ItemCode,
            //    traySpec = saveMoveStockDto.TraySpec,
            //    itemQty = Convert.ToDecimal(saveMoveStockDto.ItemQty),
            //    lockLocation = true//是否需要锁定货位
            //};
            //Log.Detail(logPara, "移库起点货位算法，参数为：" + JsonConvert.SerializeObject(oAe));
            //OutAssignResultEntity oaEresult = BLLCreator.Create<Out_AlgorBLL>().OutAssign(oAe);
            //Log.Detail(logPara, "移库起点货位算法，结果为：" + JsonConvert.SerializeObject(oaEresult));
            //if (!oaEresult.Success) return OperateResult.Error("计算起点货位失败！原因：" + oaEresult.Msg);
            //#endregion

            //#region 转运货位（移出同排同列外面的货位）

            //var moveLocationResult = MoveLocation(oaEresult.locationCode, logPara);
            //Log.Detail(logPara, "转运货位结果：" + moveLocationResult.Success + ", 信息：" + moveLocationResult.Msg);
            //if (!moveLocationResult.Success)
            //{
            //    BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "正常" }, new { CN_S_LOCATION_CODE = oaEresult.locationCode });
            //    return OperateResult.Error(moveLocationResult.Msg);
            //}

            //#endregion

            //#region 终点货位（获取建议货位）

            ////调用入库算法，获取空货位
            //List<areaPriorClass> lstTmpArea = new List<areaPriorClass>();
            //lstTmpArea.Add(new areaPriorClass { areaCode = saveMoveStockDto.EndAreaCode.Trim(), Prior = 1 });

            //InAssignEntity iAe = new InAssignEntity()
            //{
            //    lstAreaPrior = lstTmpArea,
            //    logicAreaCode = "",
            //    objectCode = oaEresult.trayCode,
            //    projectCode = "ys001",
            //    lockLocation = false                    //是否需要锁定货位
            //};
            //iAe.lstDevice = null;
            //Log.Detail(logPara, "移库的终点货位算法参数为：" + JsonConvert.SerializeObject(iAe));
            //InAssignResultEntity irEresult = BLLCreator.Create<In_AlgorBLL>().InAssign(iAe);
            //Log.Detail(logPara, "移库的终点货位算法结果为：" + JsonConvert.SerializeObject(irEresult));
            //if (!irEresult.Success)
            //{
            //    RollBackLocation(moveLocationResult, oaEresult.locationCode, logPara);
            //    return OperateResult.Error("获取建议货位失败！原因：" + irEresult.Msg);
            //}
            //#endregion

            //#region 移动
            //if (string.IsNullOrEmpty(irEresult.locationCode))
            //{
            //    return OperateResult.Error("未计算到终点库区的建议货位！");
            //}

            //TrayOnShelfEntity entity = new TrayOnShelfEntity()
            //{
            //    CN_S_LOCATION_CODE = irEresult.locationCode,
            //    CN_S_TRAY_CODE = oaEresult.trayCode,
            //    CN_S_END_AREA_CODE = saveMoveStockDto.EndAreaCode,
            //    CN_S_DEVICE_NO = oaEresult.locationCode,
            //    CN_S_TASK_TYPE = "移库"
            //};
            //Log.Detail(logPara, "移动，参数为：" + JsonConvert.SerializeObject(entity));
            //var inResult = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().SimZTShelfMoveStock(entity, user);
            //Log.Detail(logPara, "移动，结果为：" + JsonConvert.SerializeObject(inResult));

            //if(!inResult.Success)
            //{
            //    RollBackLocation(moveLocationResult, oaEresult.locationCode, logPara);
            //    return OperateResult.Error("移动失败！原因：" + inResult.Msg);
            //}
            //else
            //{
            //    //增加库存分配量
            //    AddAllocQty(oaEresult.trayCode, saveMoveStockDto.StockCode, saveMoveStockDto.StartAreaCode, logPara);
            //}

            //#endregion
        }

        /// <summary>
        /// 回滚移动的货位
        /// </summary>
        /// <param name="result">转运结果</param>
        /// <param name="logPara">日志参数</param>
        public void RollBackLocation(OperateResult result, string locationCode, LogPara logPara)
        {
            var okList = (List<OkTask>)result.Data;
            Log.Detail(logPara, "待回滚的任务：" + JsonConvert.SerializeObject(okList));
            if (okList != null)
            {
                okList.ForEach(t =>
                {
                    BLLCreator.Create<WmsApiBaseBLL>().ExecuteState(t.taskNo, "取消", logPara);
                });
            }

            if (!string.IsNullOrEmpty(locationCode))
            {
                Log.Detail(logPara, "回滚的转运货位：" + locationCode);
                BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "正常" }, new { CN_S_LOCATION_CODE = locationCode });
            }
        }

        public OperateResult SaveCurrentMoveStock(SaveMoveStockDto saveMoveStockDto, LogPara logPara, RedisUserEntity user)
        {
            var moveStockJobDto = new MoveStockJobPara();
            moveStockJobDto.MoveStockMst = new TN_WM_MOVE_STOCK_TASK_MSTEntity
            {
                CN_GUID = Guid.NewGuid().ToString(),
                CN_S_START_AREA = saveMoveStockDto.StartAreaCode,
                CN_S_END_AREA = saveMoveStockDto.EndAreaCode,
                CN_S_STATE = "未执行",
                CN_F_QUANTITY = Convert.ToDecimal(saveMoveStockDto.ItemQty),
                CN_F_MOVE_QUANTITY = 0,
                CN_S_RESULT = "",
                CN_S_ITEM_CODE = saveMoveStockDto.ItemCode,
                CN_S_STOCK_CODE = saveMoveStockDto.StockCode,
                CN_T_MODIFY = DateTime.Now,
                CN_T_CREATE = DateTime.Now,
                CN_S_CREATOR = user.CN_S_LOGIN,
                CN_S_CREATOR_BY = user.CN_S_NAME,
                CN_S_LOT_NO = saveMoveStockDto.LotNo
            };
            try
            {
                HandleMoveStock(ref moveStockJobDto, logPara);
                if (!moveStockJobDto.BasisResponse.Success)
                {
                    RollbackTask(ref moveStockJobDto, logPara);
                    return OperateResult.Error(moveStockJobDto.BasisResponse.Message);
                }
                return OperateResult.Succeed();
            }
            catch (Exception ex)
            {
                Log.Detail(logPara, "异常：" + ex.Message);
                RollbackTask(ref moveStockJobDto, logPara);
                return OperateResult.Error(ex.Message);
            }
        }

        private void HandleMoveStock(ref MoveStockJobPara moveStockJobDto, LogPara logPara)
        {
            CalculateStartBit(ref moveStockJobDto, logPara);
            if (!moveStockJobDto.BasisResponse.Success)
                return;

            MoveOutLocation(ref moveStockJobDto, logPara);
            if (!moveStockJobDto.BasisResponse.Success)
                return;

            CalculateEndBit(ref moveStockJobDto, logPara);
            if (!moveStockJobDto.BasisResponse.Success)
                return;

            MoveLocation(ref moveStockJobDto, logPara);
            if (!moveStockJobDto.BasisResponse.Success)
                return;
        }

        private void GetMoveStockTask(ref MoveStockJobPara moveStockJobDto, LogPara logPara)
        {
            moveStockJobDto.MoveStockMst = BLLCreator.Create<MoveStockTaskBLL>().GetMst();

            if (moveStockJobDto.MoveStockMst == null)
            {
                moveStockJobDto.Error("当前没有需要执行的移库任务！", logPara);
                return;
            }

            if (moveStockJobDto.MoveStockMst.CN_F_QUANTITY <= (moveStockJobDto.MoveStockMst.CN_F_MOVE_QUANTITY + moveStockJobDto.MoveStockMst.CN_F_ALLOC_QUANTITY))
            {
                //BLLCreator.Create<MoveStockTaskBLL>().UpdateMstState(moveStockJobDto.MoveStockMst.CN_GUID, "完成", null, logPara);
                moveStockJobDto.Error("移库任务已完成！", logPara);
                return;
            }

            //检查当前起始库区、结束库区没有未执行、执行中的任务
            var taskList = BLLCreator.Create<TN_WM_TASKBLL>().GetTaskByAreaCode(moveStockJobDto.MoveStockMst.CN_S_START_AREA);
            if (taskList.Any())
            {
                moveStockJobDto.Error("当前库区：" + moveStockJobDto.MoveStockMst.CN_S_START_AREA + " 存在未完成的任务：" + LogDescribe.Content(taskList), logPara);
                return;
            }

            BLLCreator.Create<MoveStockTaskBLL>().UpdateMstState(moveStockJobDto.MoveStockMst.CN_GUID, "执行中", null, logPara);
        }

        //计算起点货位
        private void CalculateStartBit(ref MoveStockJobPara moveStockJobDto, LogPara logPara)
        {
            List<areaPriorClass> lstArea = new List<areaPriorClass>();
            areaPriorClass areaClass = new areaPriorClass();
            areaClass.areaCode = moveStockJobDto.MoveStockMst.CN_S_START_AREA;
            areaClass.Prior = 1;
            lstArea.Add(areaClass);
            //调用入库算法，获取货位
            OutAssignEnitty oAe = new OutAssignEnitty()
            {
                projectCode = "ys001",
                lstAreaPrior = lstArea,
                stockCode = moveStockJobDto.MoveStockMst.CN_S_STOCK_CODE,
                itemCode = moveStockJobDto.MoveStockMst.CN_S_ITEM_CODE,
                traySpec = "",
                itemQty = moveStockJobDto.MoveStockMst.CN_F_QUANTITY,
                lockLocation = true,//是否需要锁定货位
                lotNo = moveStockJobDto.MoveStockMst.CN_S_LOT_NO
            };
            Log.Detail(logPara, "移库起点货位算法，参数为：" + JsonConvert.SerializeObject(oAe));
            OutAssignResultEntity oaEresult = BLLCreator.Create<Out_AlgorBLL>().OutAssign(oAe);
            Log.Detail(logPara, "移库起点货位算法，结果为：" + JsonConvert.SerializeObject(oaEresult));
            if (!oaEresult.Success)
            {
                if (oaEresult.Msg.Contains("库存不足") || oaEresult.Msg.Contains("货位不足"))
                    moveStockJobDto.MoveStockMst.CN_S_STATE = "完成";

                moveStockJobDto.Error("移库起点货位计算失败！" + oaEresult.Msg, logPara);
                return;
            }
            moveStockJobDto.StartLocation = oaEresult.locationCode;
            moveStockJobDto.TrayCode = oaEresult.trayCode;
        }

        //移动货位（移出同排同列外面的货位）
        private void MoveOutLocation(ref MoveStockJobPara moveStockJobPara, LogPara logPara)
        {
            var msg = "";

            //获取当前货位所在列外面有几个满货位
            var locationExt = BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().GetSingleEntity(new { CN_S_LOCATION_CODE = moveStockJobPara.StartLocation });
            if (locationExt == null)
            {
                moveStockJobPara.Error("当前算法计算的起始货位码不正确，未在货位扩展表中找到数据！", logPara);
                return;
            }
            Log.Detail(logPara, "当前货位信息：" + LogDescribe.Content(locationExt));

            var curFloor = Convert.ToInt32(locationExt.CN_S_FLOOR);
            var locations = BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().GetList(new { CN_S_COL = locationExt.CN_S_COL, CN_S_ROW = locationExt.CN_S_ROW }).Where(w => Convert.ToInt32(w.CN_S_FLOOR) > curFloor).OrderByDescending(e => e.CN_S_FLOOR);
            Log.Detail(logPara, "同排同列且在当前货位外层的货位集合，" + LogDescribe.Content(locations.ToList()));

            var startLocations = new List<string>();
            var endLocations = new List<string>();
            var trayCodes = new List<string>();
            var isAllow = true;
            //var okList = new List<OkTask>();

            if (!locations.Any())
            {
                Log.Detail(logPara, "当前货位的外层没有阻碍！");
                moveStockJobPara.Normal();
                return;
            }

            foreach (var location in locations)
            {
                if (isAllow)
                {
                    if (Convert.ToInt32(location.CN_S_FLOOR) > curFloor)
                    {
                        if (location.CN_S_USE_STATE.Equals("满") && location.CN_S_LOCATION_STATE.Equals("正常"))
                        {
                            startLocations.Add(location.CN_S_LOCATION_CODE);

                            var trayLocation = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_LOCATIONEntity>>().GetSingleEntity(new { CN_S_LOCATION_CODE = location.CN_S_LOCATION_CODE });
                            Log.Detail(logPara, LogDescribe.Content(trayLocation));

                            if (trayLocation == null)
                            {
                                isAllow = false;
                            }
                            else
                            {
                                trayCodes.Add(trayLocation.CN_S_TRAY_CODE);
                            }

                            //调用入库算法，获取空货位
                            List<areaPriorClass> lstTmpArea = new List<areaPriorClass>();
                            lstTmpArea.Add(new areaPriorClass { areaCode = location.CN_S_AREA_CODE.Trim(), Prior = 1 });

                            InAssignEntity iAe = new InAssignEntity()
                            {
                                lstAreaPrior = lstTmpArea,
                                logicAreaCode = "",
                                objectCode = trayLocation.CN_S_TRAY_CODE,
                                projectCode = "ys001",
                                needCalLock = true,
                                lockLocation = false                 //是否需要锁定货位
                            };
                            iAe.lstDevice = null;
                            Log.Detail(logPara, "调用入库算法参数：" + JsonConvert.SerializeObject(iAe));
                            InAssignResultEntity irEresult = BLLCreator.Create<In_AlgorBLL>().InAssign(iAe);
                            Log.Detail(logPara, "调用入库算法结果：" + (irEresult.Success ? "成功" : ("失败，" + irEresult.Msg)) + "，计算的货位：" + irEresult.locationCode);
                            if (!irEresult.Success)
                            {
                                isAllow = false;
                                msg = irEresult.Msg;
                            }
                            else
                            {
                                endLocations.Add(irEresult.locationCode);
                            }
                        }
                    }
                }
            }
            //调用入库算法
            if (isAllow)
            {
                if (startLocations.Count > 0)
                {
                    List<InWorkAreaEntity> inWorkAreaEntitys = new List<InWorkAreaEntity>();
                    for (int i = 0; i < startLocations.Count; i++)
                    {
                        inWorkAreaEntitys.Add(new InWorkAreaEntity
                        {
                            isTransport = "Y",
                            startBit = startLocations[i],
                            endBit = endLocations[i],
                            projectCode = "ys001",
                            trayCode = trayCodes[i],
                            data = null,
                            isControlEndBit = "false",
                            creator = moveStockJobPara.MoveStockMst.CN_S_CREATOR,
                            creatorBy = moveStockJobPara.MoveStockMst.CN_S_CREATOR_BY
                        });
                    }
                    Log.Detail(logPara, "调用入库算法，参数：" + JsonConvert.SerializeObject(inWorkAreaEntitys));

                    var result = BLLCreator.Create<WmsApiForWxysBLL>().InWorkArea(inWorkAreaEntitys, logPara);
                    if (!result.success)
                    {
                        foreach (var taskPara in inWorkAreaEntitys)
                        {
                            BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "正常", CN_S_USE_STATE = "满" }, new { CN_S_LOCATION_CODE = taskPara.startBit });
                            BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "正常", CN_S_USE_STATE = "空" }, new { CN_S_LOCATION_CODE = taskPara.endBit });
                        }
                        Log.Detail(logPara, "执行入库方法失败！回滚所有任务，原因：" + result.errMsg + "，参数：" + JsonConvert.SerializeObject(result.okList));
                        msg = result.errMsg;
                        moveStockJobPara.Error("执行入库方法失败！原因：" + result.errMsg, logPara);
                        return;
                    }
                    else
                    {
                        moveStockJobPara.OkTasks = result.okList;
                        //moveStockJobDto.MoveOutLocationResultData = okList;

                        //向AMS下达任务
                        //var sendParamList = new List<TN_WM_TRANSPORT_TASKEntity>();
                        //var parentGuid = moveStockJobPara.MoveStockMst.CN_GUID;
                        //result.okList.ForEach(m => {
                        //    sendParamList.Add(new TN_WM_TRANSPORT_TASKEntity
                        //    {
                        //        CN_S_TASK_NO = m.taskNo,
                        //        CN_S_START_BIT = m.startBit,
                        //        CN_S_END_BIT = m.endBit,
                        //        CN_N_PRIORITY = m.priority,
                        //        CN_S_CIR_OBJ_CODE = m.trayCode,
                        //        CN_S_PROJECT_CODE = "",
                        //        CN_T_CREATE = ""
                        //    });
                        //    BLLCreator.Create<MoveStockTaskBLL>().AddDtl(parentGuid, m.taskNo, "入库", 0, null, logPara);
                        //});

                        //调用AMS，下达出库指令
                        //var amsResult = BLLCreator.Create<HH.WMS.BLL.SysMgr.TN_WM_TASKBLL>().SendTask(sendParamList, "入库");
                        //Log.Detail(logPara, "调用AMS，下达出库指令！参数：" + LogDescribe.Content(sendParamList) + "，结果：" + (amsResult.Success ? "成功！" : ("失败，" + amsResult.Exception.Message)));
                    }
                }
            }
            else
            {
                if (endLocations.Any())
                {
                    //起点
                    //foreach (var startLocation in startLocations)
                    //{
                    //    //解锁被锁定的货位 CreateDAL<TN_WM_TASKDAL>().UpdateState(endLocation, "正常", "空", "预出库锁定", null);
                    //    BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "正常", CN_S_USE_STATE = "满" }, new { CN_S_LOCATION_CODE = startLocation });
                    //}

                    foreach (var endLocation in endLocations)
                    {
                        //解锁被锁定的货位 CreateDAL<TN_WM_TASKDAL>().UpdateState(endLocation, "正常", "空", "预出库锁定", null);
                        BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "正常", CN_S_USE_STATE = "空" }, new { CN_S_LOCATION_CODE = moveStockJobPara.StartLocation });
                        Log.Detail(logPara, "解锁被锁定的货位: " + endLocation + "为正常，空！");
                    }
                }
                moveStockJobPara.Error("不能移动货位，原因：" + msg, logPara);
                return;
            }

            return;
        }

        //计算终点货位
        private void CalculateEndBit(ref MoveStockJobPara moveStockJobDto, LogPara logPara)
        {
            //调用入库算法，获取空货位
            List<areaPriorClass> lstTmpArea = new List<areaPriorClass>();
            lstTmpArea.Add(new areaPriorClass { areaCode = moveStockJobDto.MoveStockMst.CN_S_END_AREA.Trim(), Prior = 1 });

            InAssignEntity iAe = new InAssignEntity()
            {
                lstAreaPrior = lstTmpArea,
                logicAreaCode = "",
                objectCode = moveStockJobDto.TrayCode,
                projectCode = "ys001",
                needCalLock = false,
                lockLocation = false                    //是否需要锁定货位
            };
            iAe.lstDevice = null;
            Log.Detail(logPara, "移库的终点货位算法参数为：" + JsonConvert.SerializeObject(iAe));
            InAssignResultEntity irEresult = BLLCreator.Create<In_AlgorBLL>().InAssign(iAe);
            Log.Detail(logPara, "移库的终点货位算法结果为：" + JsonConvert.SerializeObject(irEresult));
            if (!irEresult.Success)
            {
                moveStockJobDto.Error("移库终点货位计算失败！" + irEresult.Msg, logPara);
            }
            moveStockJobDto.EndLocation = irEresult.locationCode;
        }

        //移动货位
        private void MoveLocation(ref MoveStockJobPara moveStockJobDto, LogPara logPara)
        {
            var entity = new TrayOnShelfEntity()
            {
                CN_S_LOCATION_CODE = moveStockJobDto.EndLocation,
                CN_S_TRAY_CODE = moveStockJobDto.TrayCode,
                CN_S_END_AREA_CODE = moveStockJobDto.MoveStockMst.CN_S_END_AREA,
                CN_S_DEVICE_NO = moveStockJobDto.StartLocation,
                CN_S_TASK_TYPE = "移库"
            };
            Log.Detail(logPara, "移动，参数为：" + JsonConvert.SerializeObject(entity));
            var inResult = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().SimZTShelfMoveStock(ref moveStockJobDto, entity, new RedisUserEntity { CN_S_LOGIN = moveStockJobDto.MoveStockMst.CN_S_CREATOR, CN_S_NAME = moveStockJobDto.MoveStockMst.CN_S_CREATOR_BY }, logPara);
            Log.Detail(logPara, "移动，结果为：" + JsonConvert.SerializeObject(inResult));

            if (!inResult.Success)
            {
                moveStockJobDto.Error("移动货位失败！原因：" + inResult.Msg, logPara);
            }
            else
            {
                //向AMS下达指令
                SendToAms(ref moveStockJobDto, logPara);
                if (!moveStockJobDto.BasisResponse.Success)
                    RollbackTask(ref moveStockJobDto, logPara);

                //增加库存分配量
                AddAllocQty(ref moveStockJobDto, logPara);
                //BLLCreator.Create<MoveStockTaskBLL>().AddMoveQty(moveStockJobDto.MoveStockMst.CN_GUID, null, logPara);
                //AddAllocQty(oaEresult.trayCode, saveMoveStockDto.StockCode, saveMoveStockDto.StartAreaCode, logPara);
            }
        }

        //增加分配量
        private void AddAllocQty(ref MoveStockJobPara moveStockJobDto, LogPara logPara)
        {
            Log.Detail(logPara, "升起始库区分配量");
            var trayItemMsts = DALCreator.Create<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new { CN_S_TRAY_CODE = moveStockJobDto.TrayCode });
            if (trayItemMsts != null)
            {
                if (trayItemMsts.Count > 0)
                {
                    foreach (var trayItemMst in trayItemMsts)
                    {
                        trayItemMst.CN_F_QUANTITY = 0;
                        trayItemMst.TrayItemDtlList = DALCreator.Create<DapperDAL<TN_WM_B_TRAY_ITEM_DTLEntity>>().GetList(new { CN_PARENT_GUID = trayItemMst.CN_GUID });
                        Log.Detail(logPara, "库区：" + moveStockJobDto.MoveStockMst.CN_S_START_AREA + "，" + LogDescribe.Content(trayItemMst));

                        foreach (var trayItemDtl in trayItemMst.TrayItemDtlList)
                        {
                            trayItemMst.CN_F_QUANTITY += Convert.ToDecimal(trayItemDtl.CN_F_PACKING_QTY);

                            var curReuslt = DALCreator.Create<TN_WM_B_AREA_QTYDAL>().AddAllocQty(new TN_WM_B_AREA_QTYEntity
                            {
                                CN_F_QUANTITY = Convert.ToDecimal(trayItemDtl.CN_F_PACKING_QTY),
                                CN_S_ITEM_CODE = trayItemMst.CN_S_ITEM_CODE,
                                CN_S_ITEM_STATE = trayItemMst.CN_S_ITEM_STATE,
                                CN_S_STOCK_AREA = moveStockJobDto.MoveStockMst.CN_S_START_AREA,
                                CN_S_LOT_NO = trayItemDtl.CN_S_LOT_NO,
                                CN_S_PRODUCTION_BATCH = trayItemMst.CN_S_PRODUCTION_BATCH
                            }, null, logPara);
                            Log.Detail(logPara, LogDescribe.Content(trayItemMst) + " 库区量表执行结果：" + LogDescribe.Content(curReuslt));
                        }
                    }
                }
            }
        }

        private void SendToAms(ref MoveStockJobPara moveStockJobDto, LogPara logPara)
        {
            if (moveStockJobDto.OkTasks == null) return;
            if (moveStockJobDto.OkTasks.Count() == 0) return;

            //向AMS下达任务
            var sendParamList = new List<TN_WM_TRANSPORT_TASKEntity>();
            var parentGuid = moveStockJobDto.MoveStockMst.CN_GUID;

            var count = moveStockJobDto.OkTasks.Count();
            for (var i = 0; i < count; i++)
            {
                var m = moveStockJobDto.OkTasks[i];
                if (i == (count - 1))
                {
                    var qty = DALCreator.Create<TN_WM_B_TRAY_ITEM_RELDAL>().GetItemQtyByTrayCode(m.trayCode, logPara);
                    BLLCreator.Create<MoveStockTaskBLL>().AddDtl(parentGuid, m.taskNo, "移库", qty, null, logPara);
                }
                else
                {
                    BLLCreator.Create<MoveStockTaskBLL>().AddDtl(parentGuid, m.taskNo, "入库", 0, null, logPara);
                }
                sendParamList.Add(new TN_WM_TRANSPORT_TASKEntity
                {
                    CN_S_TASK_NO = m.taskNo,
                    CN_S_START_BIT = m.startBit,
                    CN_S_END_BIT = m.endBit,
                    CN_N_PRIORITY = m.priority,
                    CN_S_CIR_OBJ_CODE = m.trayCode,
                    CN_S_PROJECT_CODE = "",
                    CN_T_CREATE = "",
                    CN_S_STOCK_CODE = m.startStock
                });
            }

            //调用AMS，下达出库指令
            var amsResult = BLLCreator.Create<HH.WMS.BLL.SysMgr.TN_WM_TASKBLL>().SendTask(sendParamList, "转运");
            Log.Detail(logPara, "调用AMS，下达出库指令！参数：" + LogDescribe.Content(sendParamList) + "，结果：" + (amsResult.Success ? "成功！" : ("失败，" + amsResult.Exception.Message)));
            if (!amsResult.Success) moveStockJobDto.Error(amsResult.Exception.Message, logPara);
        }

        private void RollbackTask(ref MoveStockJobPara moveStockJobDto, LogPara logPara)
        {
            if (!string.IsNullOrEmpty(moveStockJobDto.StartLocation))
                BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "正常" },
                    new { CN_S_LOCATION_CODE = moveStockJobDto.StartLocation });

            if (moveStockJobDto.OkTasks.Any())
            {
                Log.Detail(logPara, "待回滚的任务：" + JsonConvert.SerializeObject(moveStockJobDto.OkTasks));
                moveStockJobDto.OkTasks.ForEach(t =>
                {
                    BLLCreator.Create<WmsApiBaseBLL>().ExecuteState(t.taskNo, "取消", logPara);
                });
            }

            var state = moveStockJobDto.MoveStockMst.CN_S_STATE == "完成" ? "完成" : "执行失败";
            BLLCreator.Create<DapperBLL<TN_WM_MOVE_STOCK_TASK_MSTEntity>>().Update(new { CN_S_STATE = state, CN_S_RESULT = moveStockJobDto.BasisResponse.Message }, new { moveStockJobDto.MoveStockMst.CN_GUID });
        }
        #endregion

        #region 检查托盘（上料）

        public OperateResult CheckTrayByUpMaterial(string trayCode)
        {
            try
            {
                var trayLocation = DALCreator.Create<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().GetSingleEntity(new { CN_S_TRAY_CODE = trayCode });
                if (trayLocation == null)
                {
                    return OperateResult.Error("托盘未绑定货位!");
                }
                var locationExt = DALCreator.Create<DapperDAL<TN_WM_LOCATION_EXTEntity>>().GetSingleEntity(new { CN_S_LOCATION_CODE = trayLocation.CN_S_LOCATION_CODE });
                if (!locationExt.CN_S_LOCATION_STATE.Equals("正常"))
                {
                    return OperateResult.Error("当前托盘绑定的货位状态为" + locationExt.CN_S_LOCATION_STATE + "，不允许上料！");
                }
                AutoBomStockAreaEntity areaModel = new AutoBomStockAreaEntity();
                areaModel = CreateDAL<TN_AB_STOCK_LOCATIONDAL>().GetAreaModelByLocation(trayLocation.CN_S_LOCATION_CODE);
                if (areaModel == null)
                {
                    //非法的目的货位
                    return OperateResult.Error(string.Format("在mongo(TN_AB_B_STOCK_AREA或TN_AB_STOCK_LOCATION表)中未查询到该货位信息！", trayLocation.CN_S_LOCATION_CODE));
                }
                if (areaModel.CN_S_AREA_CLASS == "中间库" || areaModel.CN_S_AREA_CLASS == "混装区")
                {
                    //非法的目的货位
                    return OperateResult.Error(string.Format("该托盘绑定的货位{0}属于{1}，不允许上料！", trayLocation.CN_S_LOCATION_CODE, areaModel.CN_S_AREA_CLASS));
                }

                //bool result = DALCreator.Create<TN_WM_B_TRAY_LOCATIONDAL>().CheckTrayBindLoc(trayCode);
                //if (!result)
                //{
                //    return OperateResult.Error("托盘未绑定货位！");
                //}
                bool   result = DALCreator.Create<TN_WM_B_TRAY_ITEM_RELDAL>().CheckCurTrayIsHasItem(trayCode);
                if (!result)
                {
                    return OperateResult.Error("当前是空托盘！");
                }
                
                return OperateResult.Succeed();
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }

        #endregion

        #region 转运货位（移出同排同列外面的货位）

        public OperateResult MoveLocation(string locationCode, LogPara logPara = null)
        {
            var checkResult = BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "预出库锁定" }, new { CN_S_LOCATION_CODE = locationCode });
            if (!checkResult.Success)
                return OperateResult.Error("起点：" + locationCode + "锁定失败！");

            if (logPara == null)
            {
                logPara = LogType.LogPara("移动货位（移出同排同列外面的货位）");
            }

            var msg = "";

            //获取当前货位所在列外面有几个满货位
            var locationExt = BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().GetSingleEntity(new { CN_S_LOCATION_CODE = locationCode });
            if (locationExt == null)
            {
                return new OperateResult { Success = false, Msg = "当前货位码不正确！" };
            }
            Log.Detail(logPara, "当前货位信息：" + LogDescribe.Content(locationExt));

            var curFloor = Convert.ToInt32(locationExt.CN_S_FLOOR);
            var locations = BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().GetList(new { CN_S_COL = locationExt.CN_S_COL, CN_S_ROW = locationExt.CN_S_ROW }).Where(w => Convert.ToInt32(w.CN_S_FLOOR) > curFloor).OrderByDescending(e => e.CN_S_FLOOR);
            Log.Detail(logPara, "同排同列且在当前货位外层的货位集合，" + LogDescribe.Content(locations.ToList()));

            var startLocations = new List<string>();
            var endLocations = new List<string>();
            var trayCodes = new List<string>();
            var isAllow = true;
            var okList = new List<OkTask>();

            if (locations.Count() == 0)
            {
                return new OperateResult { Success = true, Msg = "当前货位的外层没有阻碍！" };
            }

            foreach (var location in locations)
            {
                if (isAllow)
                {
                    if (Convert.ToInt32(location.CN_S_FLOOR) > curFloor)
                    {
                        if (location.CN_S_USE_STATE.Equals("满") && location.CN_S_LOCATION_STATE.Equals("正常"))
                        {
                            startLocations.Add(location.CN_S_LOCATION_CODE);

                            var trayLocation = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_LOCATIONEntity>>().GetSingleEntity(new { CN_S_LOCATION_CODE = location.CN_S_LOCATION_CODE });
                            Log.Detail(logPara, LogDescribe.Content(trayLocation));

                            if (trayLocation == null)
                            {
                                isAllow = false;
                            }
                            else
                            {
                                trayCodes.Add(trayLocation.CN_S_TRAY_CODE);
                            }

                            //调用入库算法，获取空货位
                            List<areaPriorClass> lstTmpArea = new List<areaPriorClass>();
                            lstTmpArea.Add(new areaPriorClass { areaCode = location.CN_S_AREA_CODE.Trim(), Prior = 1 });

                            InAssignEntity iAe = new InAssignEntity()
                            {
                                lstAreaPrior = lstTmpArea,
                                logicAreaCode = "",
                                objectCode = trayLocation.CN_S_TRAY_CODE,
                                projectCode = "ys001",
                                lockLocation = true,//是否需要锁定货位
                                needCalLock = false
                            };
                            iAe.lstDevice = null;
                            Log.Detail(logPara, "调用入库算法参数：" + JsonConvert.SerializeObject(iAe));
                            InAssignResultEntity irEresult = BLLCreator.Create<In_AlgorBLL>().InAssign(iAe);
                            Log.Detail(logPara, "调用入库算法结果：" + (irEresult.Success ? "成功" : ("失败，" + irEresult.Msg)) + "，计算的货位：" + irEresult.locationCode);
                            if (!irEresult.Success)
                            {
                                isAllow = false;
                                msg = irEresult.Msg;
                            }
                            else
                            {
                                endLocations.Add(irEresult.locationCode);
                            }
                        }
                    }
                }
            }
            //调用入库算法
            if (isAllow)
            {
                if (startLocations.Count > 0)
                {
                    List<InWorkAreaEntity> inWorkAreaEntitys = new List<InWorkAreaEntity>();
                    for (int i = 0; i < startLocations.Count; i++)
                    {
                        inWorkAreaEntitys.Add(new InWorkAreaEntity
                        {
                            isTransport = "Y",
                            startBit = startLocations[i],
                            endBit = endLocations[i],
                            projectCode = "ys001",
                            trayCode = trayCodes[i],
                            data = null
                        });
                    }
                    Log.Detail(logPara, "调用入库方法，参数：" + JsonConvert.SerializeObject(inWorkAreaEntitys));

                    var result = BLLCreator.Create<WmsApiBaseBLL>().InWorkArea(inWorkAreaEntitys, logPara);
                    if (!result.success)
                    {
                        //回滚所有任务（取消所有任务）
                        result.okList.ForEach(t =>
                        {
                            //取消任务
                            BLLCreator.Create<WmsApiBaseBLL>().ExecuteState(t.taskNo, "取消", logPara);
                        });

                        foreach (var taskPara in inWorkAreaEntitys)
                        {
                            BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "正常", CN_S_USE_STATE = "满" }, new { CN_S_LOCATION_CODE = taskPara.startBit });
                            BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "正常", CN_S_USE_STATE = "空" }, new { CN_S_LOCATION_CODE = taskPara.endBit });
                        }

                        Log.Detail(logPara, "执行入库方法失败！回滚所有任务，原因：" + result.errMsg + "，参数：" + JsonConvert.SerializeObject(result.okList));
                        msg = result.errMsg;
                        return OperateResult.Error("执行入库方法失败！原因：" + result.errMsg);
                    }
                    else
                    {
                        okList = result.okList;

                        //向AMS下达任务
                        var sendParamList = result.okList.Select(m => new TN_WM_TRANSPORT_TASKEntity
                        {
                            CN_S_TASK_NO = m.taskNo,
                            CN_S_START_BIT = m.startBit,
                            CN_S_END_BIT = m.endBit,
                            CN_N_PRIORITY = m.priority,
                            CN_S_CIR_OBJ_CODE = m.trayCode,
                            CN_S_PROJECT_CODE = "",
                            CN_T_CREATE = ""
                        }).ToList();

                        //调用AMS，下达出库指令
                        var amsResult = BLLCreator.Create<HH.WMS.BLL.SysMgr.TN_WM_TASKBLL>().SendTask(sendParamList, "入库");
                        Log.Detail(logPara, "调用AMS，下达出库指令！参数：" + LogDescribe.Content(sendParamList) + "，结果：" + (amsResult.Success ? "成功！" : ("失败，" + amsResult.Exception.Message)));
                    }
                }
            }
            else
            {
                if (endLocations.Count() > 0)
                {
                    foreach (var endLocation in endLocations)
                    {
                        //解锁被锁定的货位 CreateDAL<TN_WM_TASKDAL>().UpdateState(endLocation, "正常", "空", "预出库锁定", null);
                        BLLCreator.Create<DapperBLL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = "正常", CN_S_USE_STATE = "空" }, new { CN_S_LOCATION_CODE = locationCode });
                        Log.Detail(logPara, "解锁被锁定的货位: " + endLocation + "为正常，空！");
                    }
                }
                return new OperateResult { Success = false, Msg = "不能移动货位，原因：" + msg };
            }

            return new OperateResult { Success = true, Data = okList };
        }

        #endregion

        #region 增加库区分配量

        public void AddAllocQty(string trayCode, string stockCode, string areaCode, LogPara logPara)
        {
            Log.Detail(logPara, "升起始库区分配量");
            var trayItemMsts = CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new { CN_S_TRAY_CODE = trayCode }); 
            if (trayItemMsts != null)
            {
                if (trayItemMsts.Count > 0)
                {
                    foreach (var trayItemMst in trayItemMsts)
                    {
                        Log.Detail(logPara, "库区：" + areaCode + "，" + LogDescribe.Content(trayItemMst));
                        trayItemMst.TrayItemDtlList = CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_DTLEntity>>().GetList(new { CN_PARENT_GUID = trayItemMst.CN_GUID });
                        foreach (var trayItemDtl in trayItemMst.TrayItemDtlList)
                        {
                            var curReuslt = CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAllocQty(new TN_WM_B_AREA_QTYEntity
                            {
                                CN_F_QUANTITY = Convert.ToDecimal(trayItemDtl.CN_F_PACKING_QTY),
                                CN_S_ITEM_CODE = trayItemMst.CN_S_ITEM_CODE,
                                CN_S_ITEM_STATE = trayItemMst.CN_S_ITEM_STATE,
                                CN_S_STOCK_AREA = areaCode,
                                CN_S_LOT_NO = trayItemDtl.CN_S_LOT_NO,
                                CN_S_PRODUCTION_BATCH = trayItemMst.CN_S_PRODUCTION_BATCH
                            }, null, logPara);
                            Log.Detail(logPara, LogDescribe.Content(trayItemMst) + " 库区量表执行结果：" + LogDescribe.Content(curReuslt));
                            curReuslt = CreateDAL<TN_WM_B_STOCK_QTYDAL>().AddAllocQty(new TN_WM_B_STOCK_QTYEntity
                            {
                                CN_F_QUANTITY = Convert.ToDecimal(trayItemDtl.CN_F_PACKING_QTY),
                                CN_S_ITEM_CODE = trayItemMst.CN_S_ITEM_CODE,
                                CN_S_ITEM_STATE = trayItemMst.CN_S_ITEM_STATE,
                                CN_S_STOCK_CODE = stockCode,
                                CN_S_LOT_NO = trayItemDtl.CN_S_LOT_NO,
                                CN_S_PRODUCTION_BATCH = trayItemMst.CN_S_PRODUCTION_BATCH
                            }, null, logPara);
                            Log.Detail(logPara, LogDescribe.Content(trayItemMst) + " 仓库量表执行结果：" + LogDescribe.Content(curReuslt));
                        }

                    }
                }
            }
        }

        #endregion

        public OperateResult SaveCarryPDA(TN_WM_CHECK_MAINEntity entity, RedisUserEntity user)
        {
            List<TN_WM_LOCATION_EXTEntity> GetModel = BLLCreator.Create<TN_WM_LOCATION_EXTBLL>().GetModel("where CN_S_LOCATION_CODE='" + entity.CN_S_LOCATION_CODE + "'");
            if (GetModel.Count == 0)
            {
                return OperateResult.Error("在表TN_WM_LOCATION_EXT中未查询到该货位！");
            }
            AutoBomStockAreaEntity areaModel = DALCreator.Create<TN_AB_STOCK_LOCATIONDAL>().GetAreaModelByLocation(entity.CN_S_LOCATION_CODE);
            if (areaModel == null)
            {
                //非法的目的货位
                return OperateResult.Error(string.Format("在mongo(TN_AB_B_STOCK_AREA或TN_AB_STOCK_LOCATION表)中未查询到该货位信息！", entity.CN_S_LOCATION_CODE));
            }
            //货位状态：正常
            if (GetModel[0].CN_S_LOCATION_STATE != Constants.Location_Carry_Lock)
            {
                return OperateResult.Error(string.Format("当前货位状态为{0},不允许搬运上料,请先锁定货位！", GetModel[0].CN_S_LOCATION_STATE));
            }
            string carryType = entity.row.Count == 0 ? "all" : "part";

            //获取原托盘中的数据
            List<TN_WM_DOWN_HISTORYEntity> downHis = new List<TN_WM_DOWN_HISTORYEntity>();
            List<TN_WM_B_TRAY_ITEM_MSTEntity> lstOriginalMST = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new { CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE });
            List<TN_WM_B_TRAY_ITEM_DTLEntity> lstOriginalDTL = new List<TN_WM_B_TRAY_ITEM_DTLEntity>();
            List<TN_WM_B_TRAY_ITEM_MSTEntity> lstOriginalMST_U = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
            List<TN_WM_B_TRAY_ITEM_MSTEntity> lstOriginalMST_D = new List<TN_WM_B_TRAY_ITEM_MSTEntity>();
            List<TN_WM_B_STOCK_QTYEntity> reduceStockQty = new List<TN_WM_B_STOCK_QTYEntity>();
            List<TN_WM_B_AREA_QTYEntity> reduceAreaQty = new List<TN_WM_B_AREA_QTYEntity>();
            if (carryType == "all")
            {
                foreach (TN_WM_B_TRAY_ITEM_MSTEntity mstEntity in lstOriginalMST)
                {
                    lstOriginalDTL = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_ITEM_DTLEntity>>().GetList(new { CN_PARENT_GUID = mstEntity.CN_GUID });
                    foreach (TN_WM_B_TRAY_ITEM_DTLEntity dltEntity in lstOriginalDTL)
                    {
                        #region 拼接下架记录表
                        TN_WM_DOWN_HISTORYEntity down = new TN_WM_DOWN_HISTORYEntity();
                        down.CN_GUID = Guid.NewGuid().ToString();
                        down.CN_S_CREATOR = user.CN_S_LOGIN;
                        down.CN_S_CREATOR_BY = user.CN_S_NAME;
                        down.CN_S_MODIFY = user.CN_S_LOGIN;
                        down.CN_S_MODIFY_BY = user.CN_S_NAME;
                        down.CN_F_QUANTITY = Decimal.Parse(dltEntity.CN_S_SERIAL_NO);
                        down.CN_F_PACKING_QTY = dltEntity.CN_F_PACKING_QTY;
                        //宇寿项目存放指令批号
                        down.CN_S_LOT_NO = dltEntity.CN_S_LOT_NO == null ? "" : dltEntity.CN_S_LOT_NO;
                        //宇寿项目存放工单号
                        down.CN_S_FIGURE_NO = dltEntity.CN_S_EXT1;
                        down.CN_S_ITEM_CODE = mstEntity.CN_S_ITEM_CODE;
                        down.CN_S_ITEM_NAME = mstEntity.CN_S_ITEM_NAME;
                        down.CN_S_ITEM_STATE = mstEntity.CN_S_ITEM_STATE == null ? "" : mstEntity.CN_S_ITEM_STATE;
                        down.CN_S_LOCATION_CODE = entity.CN_S_LOCATION_CODE;
                        down.CN_S_MEASURE_UNIT = mstEntity.CN_S_MEASURE_UNIT;
                        down.CN_S_MODEL = mstEntity.CN_S_MODEL;
                        down.CN_S_OWNER = mstEntity.CN_S_OWNER == null ? "" : mstEntity.CN_S_OWNER;
                        down.CN_S_PACKING_UNIT = "";
                        down.CN_S_PRODUCTION_BATCH = dltEntity.CN_S_PRODUCTION_BATCH == null ? "" : mstEntity.CN_S_PRODUCTION_BATCH;
                        down.CN_S_STOCK_AREA = areaModel.CN_S_AREA_CODE;
                        down.CN_S_STOCK_CODE = areaModel.CN_S_STOCK_CODE;
                        down.CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE;
                        down.CN_S_PRODUCTION_BATCH = entity.WORK_CENTER;
                        down.CN_S_TRAY_GRID = "1";
                        down.CN_S_EXT1 = dltEntity.CN_S_UNIQUE_CODE;
                        //宇寿存储入库类型  正常入库 其他入库
                        down.CN_S_EXT2 = entity.OUT_STOCK_TYPE;
                        down.CN_T_CREATE = down.CN_T_MODIFY = DateTime.Now;
                        down.CN_S_OP_FROM = "PDA人工搬运整托出库";
                        downHis.Add(down);
                        #endregion
                    }
                }
            }
            else
            {
                string uniqueCodes = string.Join(",", entity.row.Select(o => o.CN_S_PACK_CODE).ToList());
                lstOriginalDTL = DALCreator.Create<TN_WM_B_TRAY_ITEM_RELDAL>().GetDtlByUniques(uniqueCodes);
                foreach (var trayItemMst in lstOriginalMST)
                {
                    var curTrayItemDtls = lstOriginalDTL.Where(e => e.CN_PARENT_GUID.Equals(trayItemMst.CN_GUID));
                    if (curTrayItemDtls.Count() > 0)
                    {
                        trayItemMst.CN_F_QUANTITY -= curTrayItemDtls.Count();
                        if (trayItemMst.CN_F_QUANTITY > 0)
                        {
                            lstOriginalMST_U.Add(trayItemMst);
                            //DALCreator.Create<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().Update(new { trayItemMst.CN_F_QUANTITY }, new { CN_GUID = trayItemMst.CN_GUID }, trans);
                        }
                        else
                        {
                            lstOriginalMST_D.Add(trayItemMst);
                            //result = DALCreator.Create<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().Delete(new { CN_GUID = trayItemMst.CN_GUID }, trans);
                        }
                    }
                    foreach (TN_WM_B_TRAY_ITEM_DTLEntity dltEntity in curTrayItemDtls)
                    {
                        #region 拼接下架记录表
                        TN_WM_DOWN_HISTORYEntity down = new TN_WM_DOWN_HISTORYEntity();
                        down.CN_GUID = Guid.NewGuid().ToString();
                        down.CN_S_CREATOR = user.CN_S_LOGIN;
                        down.CN_S_CREATOR_BY = user.CN_S_NAME;
                        down.CN_S_MODIFY = user.CN_S_LOGIN;
                        down.CN_S_MODIFY_BY = user.CN_S_NAME;
                        down.CN_F_QUANTITY = Decimal.Parse(dltEntity.CN_S_SERIAL_NO);
                        down.CN_F_PACKING_QTY = dltEntity.CN_F_PACKING_QTY;
                        //宇寿项目存放指令批号
                        down.CN_S_LOT_NO = dltEntity.CN_S_LOT_NO == null ? "" : dltEntity.CN_S_LOT_NO;
                        //宇寿项目存放工单号
                        down.CN_S_FIGURE_NO = dltEntity.CN_S_EXT1;
                        down.CN_S_ITEM_CODE = trayItemMst.CN_S_ITEM_CODE;
                        down.CN_S_ITEM_NAME = trayItemMst.CN_S_ITEM_NAME;
                        down.CN_S_ITEM_STATE = trayItemMst.CN_S_ITEM_STATE == null ? "" : trayItemMst.CN_S_ITEM_STATE;
                        down.CN_S_LOCATION_CODE = entity.CN_S_LOCATION_CODE;
                        down.CN_S_MEASURE_UNIT = trayItemMst.CN_S_MEASURE_UNIT;
                        down.CN_S_MODEL = trayItemMst.CN_S_MODEL;
                        down.CN_S_OWNER = trayItemMst.CN_S_OWNER == null ? "" : trayItemMst.CN_S_OWNER;
                        down.CN_S_PACKING_UNIT = "";
                        down.CN_S_PRODUCTION_BATCH = dltEntity.CN_S_PRODUCTION_BATCH == null ? "" : trayItemMst.CN_S_PRODUCTION_BATCH;
                        down.CN_S_STOCK_AREA = areaModel.CN_S_AREA_CODE;
                        down.CN_S_STOCK_CODE = areaModel.CN_S_STOCK_CODE;
                        down.CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE;
                        down.CN_S_TRAY_GRID = "1";
                        down.CN_S_EXT1 = dltEntity.CN_S_UNIQUE_CODE;
                        down.CN_S_PRODUCTION_BATCH = entity.WORK_CENTER;
                        //宇寿存储入库类型  正常入库 其他入库
                        down.CN_S_EXT2 = entity.OUT_STOCK_TYPE;
                        down.CN_T_CREATE = down.CN_T_MODIFY = DateTime.Now;
                        down.CN_S_OP_FROM = "PDA人工搬运部分出库";
                        downHis.Add(down);
                        #endregion
                    }
                }

            }

            #region 仓库量表


            reduceStockQty = downHis.GroupBy(x => new
            {
                CN_S_ITEM_CODE = x.CN_S_ITEM_CODE,
                CN_S_ITEM_NAME = x.CN_S_ITEM_NAME,
                CN_S_ITEM_STATE = x.CN_S_ITEM_STATE,
                CN_S_STOCK_CODE = x.CN_S_STOCK_CODE,
                CN_S_OWNER = x.CN_S_OWNER,
                CN_S_LOT_NO = x.CN_S_LOT_NO,
                CN_S_MODEL = x.CN_S_MODEL,
                CN_S_MEASURE_UNIT = x.CN_S_MEASURE_UNIT,
                CN_S_FIGURE_NO = x.CN_S_FIGURE_NO
            }).Select(y =>
            {
                return new TN_WM_B_STOCK_QTYEntity()
                {
                    CN_F_QUANTITY = y.Sum(k =>Convert.ToDecimal(k.CN_F_PACKING_QTY)),
                    CN_S_ITEM_CODE = y.Key.CN_S_ITEM_CODE,
                    CN_S_ITEM_NAME = y.Key.CN_S_ITEM_NAME,
                    CN_S_ITEM_STATE = y.Key.CN_S_ITEM_STATE,
                    CN_S_LOT_NO = y.Key.CN_S_LOT_NO,
                    CN_S_MODEL = y.Key.CN_S_MODEL,
                    CN_S_MEASURE_UNIT = y.Key.CN_S_MEASURE_UNIT,
                    CN_S_FIGURE_NO = y.Key.CN_S_FIGURE_NO,
                    CN_S_OWNER = y.Key.CN_S_OWNER,
                    CN_S_STOCK_CODE = y.Key.CN_S_STOCK_CODE
                };
            }).ToList();

            #endregion
            #region 库区量表

            reduceAreaQty = downHis.GroupBy(x => new
            {
                CN_S_ITEM_CODE = x.CN_S_ITEM_CODE,
                CN_S_ITEM_NAME = x.CN_S_ITEM_NAME,
                CN_S_ITEM_STATE = x.CN_S_ITEM_STATE,
                CN_S_STOCK_AREA = x.CN_S_STOCK_AREA,
                CN_S_STOCK_CODE = x.CN_S_STOCK_CODE,
                CN_S_OWNER = x.CN_S_OWNER,
                CN_S_LOT_NO = x.CN_S_LOT_NO,
                CN_S_MODEL = x.CN_S_MODEL,
                CN_S_MEASURE_UNIT = x.CN_S_MEASURE_UNIT,
                CN_S_FIGURE_NO = x.CN_S_FIGURE_NO
            }).Select(y =>
            {
                return new TN_WM_B_AREA_QTYEntity()
                {
                    CN_F_QUANTITY = y.Sum(k => Convert.ToDecimal(k.CN_F_PACKING_QTY)),
                    CN_S_ITEM_CODE = y.Key.CN_S_ITEM_CODE,
                    CN_S_ITEM_NAME = y.Key.CN_S_ITEM_NAME,
                    CN_S_ITEM_STATE = y.Key.CN_S_ITEM_STATE,
                    CN_S_LOT_NO = y.Key.CN_S_LOT_NO,
                    CN_S_OWNER = y.Key.CN_S_OWNER,
                    CN_S_MODEL = y.Key.CN_S_MODEL,
                    CN_S_MEASURE_UNIT = y.Key.CN_S_MEASURE_UNIT,
                    CN_S_FIGURE_NO = y.Key.CN_S_FIGURE_NO,
                    CN_S_STOCK_AREA = y.Key.CN_S_STOCK_AREA,
                    CN_S_STOCK_CODE = y.Key.CN_S_STOCK_CODE
                };
            }).ToList();
            #endregion

            OperateResult operateResult = UseTransaction(trans =>
            {

                if (carryType == "all")
                {
                    #region 整托业务处理
                    operateResult = CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationExtStateLock(entity.CN_S_LOCATION_CODE, Constants.Location_State_Normal, Constants.Location_Carry_Lock, Constants.Use_State_Empty, "", trans);

                    if (operateResult.AffectedRows == 0)
                    {
                        throw new Exception("搬运上料解锁货位状态并发冲突,该货位状态可能已经发生变化");
                    }
                    BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(entity.CN_S_LOCATION_CODE, Constants.Location_Carry_Lock, Constants.Location_State_Normal, "PDA搬运解锁货位", "PDA", user.CN_S_LOGIN, "", areaModel.CN_S_STOCK_CODE, areaModel.CN_S_AREA_CODE, trans);
                    //删除托盘中的物料
                    BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().Delete(" CN_S_TRAY_CODE='" + entity.CN_S_TRAY_CODE + "' ", trans);
                    //删除托盘货位关联
                    DALCreator.Create<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new { CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE }, trans);
                    //影响库存
                    if (areaModel.CN_C_IS_INVENTORY != null)
                    {
                        if (areaModel.CN_C_IS_INVENTORY == "Y")
                        {
                            //更新仓库量表
                            if (reduceStockQty.Any())
                                CreateDAL<TN_WM_B_STOCK_QTYDAL>().ReduceStockQty(reduceStockQty, trans);
                            //更新库区量表
                            if (reduceAreaQty.Any())
                                CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaQty(reduceAreaQty, trans);
                            //下架记录
                            if (downHis.Any())
                                CreateDAL<DapperDAL<TN_WM_DOWN_HISTORYEntity>>().AddRange(downHis, trans);
                        }

                    }
                    //修改托盘的存储状态
                    CreateDAL<DapperDAL<TN_WM_B_TRAY_INFOEntity>>().Update(new
                    {
                        CN_S_USE_STATE = "空"
                    }, new
                    {
                        CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE
                    }, trans);
                    #endregion
                }
                else
                {
                    #region 部分上料业务处理
                    operateResult = CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationExtStateLock(entity.CN_S_LOCATION_CODE, Constants.Location_State_Normal, Constants.Location_Carry_Lock, "", "", trans);

                    if (operateResult.AffectedRows == 0)
                    {
                        throw new Exception("搬运上料解锁货位状态并发冲突,该货位状态可能已经发生变化");
                    }
                    BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(entity.CN_S_LOCATION_CODE, Constants.Location_Carry_Lock, Constants.Location_State_Normal, "PDA搬运解锁货位", "PDA", user.CN_S_LOGIN, "", areaModel.CN_S_STOCK_CODE, areaModel.CN_S_AREA_CODE, trans);

                    //删除托盘中被上料的数据
                    lstOriginalMST_U.ForEach(e =>
                    {
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().Update(new { CN_F_QUANTITY = e.CN_F_QUANTITY }, new { CN_GUID = e.CN_GUID }, trans);
                    });

                    lstOriginalMST_D.ForEach(e =>
                    {
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().Delete(new { CN_GUID = e.CN_GUID }, trans);
                    });
                    lstOriginalDTL.ForEach(e =>
                    {
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_DTLEntity>>().Delete(new { CN_GUID = e.CN_GUID }, trans);
                    });
                    //影响库存
                    if (areaModel.CN_C_IS_INVENTORY != null)
                    {
                        if (areaModel.CN_C_IS_INVENTORY == "Y")
                        {
                            //更新仓库量表
                            if (reduceStockQty.Any())
                                CreateDAL<TN_WM_B_STOCK_QTYDAL>().ReduceStockQty(reduceStockQty, trans);
                            //更新库区量表
                            if (reduceAreaQty.Any())
                                CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaQty(reduceAreaQty, trans);
                            //下架记录
                            if (downHis.Any())
                                CreateDAL<DapperDAL<TN_WM_DOWN_HISTORYEntity>>().AddRange(downHis, trans);
                        }

                    }
                    CreateDAL<DapperDAL<TN_WM_B_TRAY_INFOEntity>>().Update(new
                    {
                        CN_S_USE_STATE = "不满"
                    }, new
                    {
                        CN_S_TRAY_CODE = entity.CN_S_TRAY_CODE
                    }, trans);
                    #endregion
                }

            });
            if (operateResult.Success)
            {
                foreach (var TN_WM_DOWN_HISTORYEntity in downHis)
                {
                    //更新BARCODE表使用状态
                    var resultCur = BLLCreator.Create<MONGO_PRINT_BARCODEBLL>().UpdateUpMetarialState(TN_WM_DOWN_HISTORYEntity.CN_S_EXT1, "N");
                   // Log.Detail("唯一码：" + TN_WM_DOWN_HISTORYEntity.CN_S_EXT1 + "，更新BARCODE表使用状态结果：" + (resultCur ? "成功!" : "失败"));
                }
            }

            return operateResult;
        }

        public OperateResult GetAreaQty(string itemCode, string lotNo, string areaCode)
        {
            try
            {
                DataTable dt = DALCreator.Create<YsApiDAL>().GetAreaQty(itemCode, lotNo, areaCode);
                //AutoBomItemEntity item = CreateDAL<TN_WMS_ITEMDAL>().GetItemEntity(itemCode);
                //dt.Columns.Add("CN_F_QUANTITY", Type.GetType("System.String"));
                //foreach (DataRow dr in dt.Rows)
                //{
                //    if (item.CN_F_NW != 0)
                //    {
                //        dr["CN_F_QUANTITY"] = Math.Round(Convert.ToDecimal(dr["CN_S_SERIAL_NO"]) / item.CN_F_NW).ToString();
                //    }
                //    else
                //    {
                //        dr["CN_F_QUANTITY"] = "0";
                //    }
                //    dr["CN_S_MEASURE_UNIT"] = item.CN_S_MEASURE_UNIT;
                //}
                return OperateResult.Succeed("", dt);
            }
            catch (Exception ex)
            {
                Log.Error("GetAreaQty异常:====>", ex.Message + ex.StackTrace);
                return OperateResult.Error(ex.Message);
            }

        }
    }
}