using HH.WMS.BLL.Algorithm;
using HH.WMS.BLL.Basic;
using HH.WMS.BLL.ERP;
using HH.WMS.BLL.InStock;
using HH.WMS.BLL.Interface;
using HH.WMS.BLL.SysMgr;
using HH.WMS.Common;
using HH.WMS.Common.Algorithm;
using HH.WMS.Common.External;
using HH.WMS.Common.Response;
using HH.WMS.DAL;
using HH.WMS.DAL.Algorithm;
using HH.WMS.DAL.Basic;
using HH.WMS.DAL.MoveStock;
using HH.WMS.DAL.SysMgr;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Algorithm;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Dto;
using HH.WMS.Entitys.Entitys;
using HH.WMS.Entitys.ERP;
using HH.WMS.Entitys.External;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;

namespace HH.WMS.BLL.External
{
    public class WmsApiForNtsdBLL : WmsApiBaseBLL
    {
        #region 入库

        public override ExternalResponse InWorkArea(List<InWorkAreaEntity> inWorkAreaEntitys, LogPara logPara)
        {
            var response = new ExternalResponse();
            if (inWorkAreaEntitys == null) return new ExternalResponse { success = false, errMsg = "参数不正确", errCode = "102" };
            if (inWorkAreaEntitys.Count() == 0) return new ExternalResponse { success = false, errMsg = "参数不正确", errCode = "102" };
            var result = InWorkArea(inWorkAreaEntitys[0], logPara);
            if (result.BasisResponse.Success)
            {
                response.success = true;
                response.errCode = "100";
                response.okList.Add(result.TaskExecuteState.okTask);
                //发送到AMS
                // SendToAms(response, logPara);
            }
            else
            {
                if (result.BasisResponse.Message.Contains("空托不能原料入库"))
                {
                    response.errCode = "201";
                }
                else if (result.BasisResponse.Message.Contains("未找到合适的入库货位"))
                {
                    response.errCode = "200";
                }
                else
                {
                    response.errCode = "201";
                }

                response.failList.Add(result.TaskExecuteState.Error(0, result.BasisResponse.Message).FailTask);
                //入库转运锁定起点的，如果执行不成功则解锁
                if (result.RollbackLocations.Count > 0)
                {
                    foreach (string sLocation in result.RollbackLocations)
                    {
                        BLLCreator.Create<TN_WM_LOCATION_EXTBLL>().UpdateState(sLocation, Constants.Location_State_Normal, "");
                        AutoBomLocationEntity locationModel = CreateDAL<TN_WMS_LOCATIONDAL>().GetModel(sLocation);
                        BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(sLocation, "", "正常", "出库请求失败回滚过程中锁定的货位", inWorkAreaEntitys[0].sysName, "", "", locationModel.CN_S_STOCK_CODE, locationModel.CN_S_AREA_CODE, null);
                    }
                }
            }

            return response;
            //var curResult = (response.failList.Any() ? response.Error(null, string.Empty, inWorkAreaEntitys) : response.Ok(null, inWorkAreaEntitys));
            //return curResult;
        }

        public override ExecuteInWorkAreaPara InWorkAreaVerifyPara(ref ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            Log.Detail(logPara, "南通验证参数！");

            if (executeInWorkAreaPara.InWorkAreaEntity.isTransport == null) executeInWorkAreaPara.InWorkAreaEntity.isTransport = "N";

            //if (executeInWorkAreaPara.InWorkAreaEntity.trayWeight != null)
            if (executeInWorkAreaPara.InWorkAreaEntity.trayWeight > 0)
                executeInWorkAreaPara.InWorkAreaEntity.taskType = "原料入库";

            //物料编码_对象不为空时，必须存在物料编码
            if (executeInWorkAreaPara.InWorkAreaEntity.data != null)
                if (executeInWorkAreaPara.InWorkAreaEntity.data.Any(entity => string.IsNullOrEmpty(entity.itemCode)))
                {
                    executeInWorkAreaPara.BasisResponse = BasisResponse.Error("物料编码为空" + JsonConvert.SerializeObject(executeInWorkAreaPara.InWorkAreaEntity.data));
                    return executeInWorkAreaPara;
                }

            //任务号_当任务号不为空时，系统判断任务号是否重复
            if (!string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.taskNo))
            {
                if (DALCreator.Create<TN_WM_TASKDAL>().GetTaskByTaskNo(executeInWorkAreaPara.InWorkAreaEntity.taskNo).Count > 0)
                {
                    executeInWorkAreaPara.BasisResponse = BasisResponse.Error("任务号" + executeInWorkAreaPara.InWorkAreaEntity.taskNo + "重复！");
                    return executeInWorkAreaPara;
                }
            }

            //起始库区
            if (string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.startBit))
            {
                executeInWorkAreaPara.BasisResponse = BasisResponse.Error("参数中缺少起始位置！" + executeInWorkAreaPara.InWorkAreaEntity.startBit);
                return executeInWorkAreaPara;
            }
            else
            {
                //缓存起始库区实体
                executeInWorkAreaPara.StartStockAreaEntity = DALCreator.Create<TN_AB_STOCK_LOCATIONDAL>().GetAreaModelByLocation(executeInWorkAreaPara.InWorkAreaEntity.startBit.Trim());
                if (executeInWorkAreaPara.StartStockAreaEntity == null)
                {
                    executeInWorkAreaPara.BasisResponse = BasisResponse.Error("当前起始位置未找到对应的库区！" + executeInWorkAreaPara.InWorkAreaEntity.startBit);
                    return executeInWorkAreaPara;
                }

                Log.Detail(logPara, "起点是否管控QTY：" + executeInWorkAreaPara.StartStockAreaEntity.CN_C_IS_CONTROL_QTY);
                // 检查货位状态  是转运且管控数量时使用
                if (executeInWorkAreaPara.StartStockAreaEntity.CN_C_IS_CONTROL_QTY.Equals("Y"))
                {
                    executeInWorkAreaPara.StartLocationExt = BLLCreator.Create<TN_WM_LOCATION_EXTBLL>().GetModel(" where CN_S_LOCATION_CODE = '" + executeInWorkAreaPara.InWorkAreaEntity.startBit.Trim() + "'").FirstOrDefault();
                    if (!executeInWorkAreaPara.StartLocationExt.CN_S_LOCATION_STATE.Equals("正常"))
                    {
                        executeInWorkAreaPara.BasisResponse = BasisResponse.Error("当前起始货位状态为" + executeInWorkAreaPara.StartLocationExt.CN_S_LOCATION_STATE + "，货位不可用！");
                        return executeInWorkAreaPara;
                    }
                    if (!executeInWorkAreaPara.StartLocationExt.CN_S_USE_STATE.Equals("满"))
                    {
                        if (!executeInWorkAreaPara.StartStockAreaEntity.CN_S_AREA_CODE.Equals("CPMRK"))
                        {
                            executeInWorkAreaPara.BasisResponse = BasisResponse.Error("当前起始货位存储状态为" + executeInWorkAreaPara.StartLocationExt.CN_S_USE_STATE + "，货位不可用！");
                            return executeInWorkAreaPara;
                        }
                    }

                    //锁定起点货位
                    OperateResult lockResult = BLLCreator.Create<HH.WMS.BLL.Basic.TN_WM_LOCATION_EXTBLL>().UpdateState(executeInWorkAreaPara.InWorkAreaEntity.startBit, "预出库锁定", "正常");
                    if (lockResult.Success && lockResult.AffectedRows > 0)
                    {
                        AutoBomLocationEntity locationModel = DALCreator.Create<TN_WMS_LOCATIONDAL>().GetModel(executeInWorkAreaPara.InWorkAreaEntity.startBit);
                        //添加货位状态变化
                        BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeInWorkAreaPara.InWorkAreaEntity.startBit, "正常", "预出库锁定", "入库并且转运需要锁定起点货位防止其他资源竞争", executeInWorkAreaPara.InWorkAreaEntity.sysName, "", "", locationModel.CN_S_STOCK_CODE, locationModel.CN_S_AREA_CODE, null);
                        executeInWorkAreaPara.RollbackLocations.Add(executeInWorkAreaPara.InWorkAreaEntity.startBit);
                    }
                    else
                    {
                        if (!lockResult.Success)
                        {
                            executeInWorkAreaPara.BasisResponse = BasisResponse.Error("锁定起点货位" + executeInWorkAreaPara.InWorkAreaEntity.startBit + "失败！详细原因为：" + lockResult.Msg);
                        }
                        else
                        {
                            executeInWorkAreaPara.BasisResponse = BasisResponse.Error("锁定起点货位" + executeInWorkAreaPara.InWorkAreaEntity.startBit + "失败！详细原因为：SqlExecuteResult影响行数为0");
                        }
                        return executeInWorkAreaPara;
                    }
                }
                //检查起点货位是否为报废状态 
                executeInWorkAreaPara.InWorkAreaEntity.startArea = executeInWorkAreaPara.StartStockAreaEntity.CN_S_AREA_CODE;
                executeInWorkAreaPara.InWorkAreaEntity.startStock = executeInWorkAreaPara.StartStockAreaEntity.CN_S_STOCK_CODE;
            }
            return executeInWorkAreaPara;
        }

        public override ExecuteInWorkAreaPara InWorkAreaHandlePara(ref ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            //任务号 考虑是否重复？
            if (string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.taskNo))
            {
                var postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.Rule_InTaskNo + "\",\"orgId\":\"0\",\"orgFlag\":\"\"}";
                executeInWorkAreaPara.InWorkAreaEntity.taskNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData); ;
                if (string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.taskNo))
                {
                    executeInWorkAreaPara.BasisResponse = BasisResponse.Error("获取AUTOBOM入库任务号异常,请检查是否维护生成规则！");
                    return executeInWorkAreaPara;
                }
            }

            //托盘码
            if (string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.trayCode))
            {
                //转运并且不传托盘号，默认从货位中获取
                if (executeInWorkAreaPara.InWorkAreaEntity.isTransport == "Y")
                {
                    //查找托盘号和物料编码 and by liuying 
                    var lstObj = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().GetListByLocationCode(executeInWorkAreaPara.InWorkAreaEntity.startBit);

                    if (lstObj.Count > 0)
                    {
                        //去除已经在任务中的托盘
                        var strTray = string.Join("','", lstObj.Select(o => o.CN_S_TRAY_CODE).ToList());
                        var lstTasks = BLLCreator.Create<TN_WM_TASKBLL>().GetTask(" AND CN_S_TRAY_CODE in ('" + strTray + "') AND (CN_S_STATE = '未执行' or CN_S_STATE = '执行中')");
                        var lstInTaskTray = lstTasks.Select(o => o.CN_S_TRAY_CODE).ToList();
                        lstObj.RemoveAll(o => lstInTaskTray.Contains(o.CN_S_TRAY_CODE));

                        if (lstObj.Count > 0)
                        {
                            executeInWorkAreaPara.InWorkAreaEntity.trayCode = lstObj[0].CN_S_TRAY_CODE;
                            var itemEntity = new ChaoYangItemDataEntity();
                            executeInWorkAreaPara.InWorkAreaEntity.data = new List<ChaoYangItemDataEntity>();

                            //根据托盘号查询托盘产品关联信息主表
                            var trayItemMst = BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().GetTrayItemMst(" AND CN_S_TRAY_CODE ='" + lstObj[0].CN_S_TRAY_CODE + "'");
                            if (trayItemMst.Count > 0)
                            {
                                //查询托盘产品关联信息子表
                                var trayItemDtl = BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().GetTrayItemDtl(" AND CN_PARENT_GUID='" + trayItemMst[0].CN_GUID + "'");
                                itemEntity.itemCode = trayItemMst[0].CN_S_ITEM_CODE;
                                itemEntity.itemName = trayItemMst[0].CN_S_ITEM_NAME;
                                itemEntity.itemPackUnit = trayItemDtl[0].CN_S_PACKING_UNIT;
                                itemEntity.qty = (decimal)(trayItemMst[0].CN_F_QUANTITY == null ? 0 : trayItemMst[0].CN_F_QUANTITY);
                                itemEntity.lotNo = trayItemDtl[0].CN_S_PRODUCTION_BATCH;
                                itemEntity.itemState = trayItemMst[0].CN_S_ITEM_STATE;
                                itemEntity.productionDate = trayItemDtl[0].CN_T_PRODUCTION;
                                itemEntity.uniqueCode = trayItemDtl[0].CN_S_UNIQUE_CODE;
                                //itemEntity.itemWeight = trayItemDtl[0].CN_S_SERIAL_NO;
                                itemEntity.itemModel = trayItemMst[0].CN_S_MODEL;
                                executeInWorkAreaPara.InWorkAreaEntity.data.Add(itemEntity);
                            }
                        }
                        else
                        {
                            executeInWorkAreaPara.BasisResponse = BasisResponse.Error("该货位" + executeInWorkAreaPara.InWorkAreaEntity.startBit + "中的托盘都已在任务中，不允许重复下达");
                        }
                    }
                    else
                    {
                        //生成虚拟托盘
                        var postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.VirtualTray + "\",\"orgId\":\"0\",\"orgFlag\":\"\"}";
                        executeInWorkAreaPara.InWorkAreaEntity.trayCode = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);
                        //executeInWorkAreaPara.BasisResponse = BasisResponse.Error("起点货位" + executeInWorkAreaPara.InWorkAreaEntity.startBit + "没有绑定托盘");
                        //return executeInWorkAreaPara;
                    }
                }
                else
                {
                    var trayLocation = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().GetByLocationCode(executeInWorkAreaPara.InWorkAreaEntity.startBit);
                    if (trayLocation == null)
                    {
                        //生成虚拟托盘
                        var postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.VirtualTray + "\",\"orgId\":\"0\",\"orgFlag\":\"\"}";
                        executeInWorkAreaPara.InWorkAreaEntity.trayCode = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);
                        //executeInWorkAreaPara.BasisResponse = BasisResponse.Error("起点货位" + executeInWorkAreaPara.InWorkAreaEntity.startBit + "没有绑定托盘");
                        //return executeInWorkAreaPara;

                    }
                    else
                    {
                        executeInWorkAreaPara.InWorkAreaEntity.trayCode = trayLocation.CN_S_TRAY_CODE;

                        var taskAll = BLLCreator.Create<DapperBLL<TN_WM_TASKEntity>>().GetList(new { CN_S_TRAY_CODE = trayLocation.CN_S_TRAY_CODE });
                        taskAll = taskAll.Where(e => e.CN_S_STATE != "取消").ToList();
                        var task = taskAll.Select(e => e.CN_S_STATE != "完成").ToList();
                        if (task.Any())
                        {
                            executeInWorkAreaPara.BasisResponse = BasisResponse.Error("当前托盘存在未完成的任务！");
                            return executeInWorkAreaPara;
                        }
                        // if (executeInWorkAreaPara.InWorkAreaEntity.projectCode == "nt001")
                        //if (executeInWorkAreaPara.TrayInfo == null)
                        //{
                        //    {
                        //        executeInWorkAreaPara.BasisResponse = BasisResponse.Error("托盘信息表无当前托盘" + trayLocation.CN_S_TRAY_CODE);
                        //        return executeInWorkAreaPara;
                        //    }
                        //}
                    }
                }
            }
            else
            {
                var itemEntity = new ChaoYangItemDataEntity();
                executeInWorkAreaPara.InWorkAreaEntity.data = new List<ChaoYangItemDataEntity>();

                //根据托盘号查询托盘产品关联信息主表
                var trayItemMst = BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().GetTrayItemMst(" AND CN_S_TRAY_CODE ='" + executeInWorkAreaPara.InWorkAreaEntity.trayCode + "'");
                if (trayItemMst.Count > 0)
                {
                    //查询托盘产品关联信息子表
                    var trayItemDtl = BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().GetTrayItemDtl(" AND CN_PARENT_GUID='" + trayItemMst[0].CN_GUID + "'");
                    itemEntity.itemCode = trayItemMst[0].CN_S_ITEM_CODE;
                    itemEntity.itemName = trayItemMst[0].CN_S_ITEM_NAME;
                    itemEntity.itemPackUnit = trayItemDtl[0].CN_S_PACKING_UNIT;
                    itemEntity.qty = (decimal)(trayItemMst[0].CN_F_QUANTITY == null ? 0 : trayItemMst[0].CN_F_QUANTITY);
                    itemEntity.lotNo = trayItemDtl[0].CN_S_PRODUCTION_BATCH;
                    itemEntity.itemState = trayItemMst[0].CN_S_ITEM_STATE;
                    itemEntity.productionDate = trayItemDtl[0].CN_T_PRODUCTION;
                    itemEntity.uniqueCode = trayItemDtl[0].CN_S_UNIQUE_CODE;
                    //itemEntity.itemWeight = trayItemDtl[0].CN_S_SERIAL_NO;
                    itemEntity.itemModel = trayItemMst[0].CN_S_MODEL;
                    executeInWorkAreaPara.InWorkAreaEntity.data.Add(itemEntity);
                }
            }
          

            //处理物料编码
            if (executeInWorkAreaPara.InWorkAreaEntity.data != null)
            {
                foreach (var itemData in executeInWorkAreaPara.InWorkAreaEntity.data)
                {
                    var item = BLLCreator.Create<HH.WMS.BLL.Basic.TN_WMS_ITEMBLL>().GetItem(itemData.itemCode);
                    //BLLCreator.Create<DapperBLL<AutoBomItemEntity>>().GetSingleEntity(new { CN_S_ITEM_CODE = itemData.itemCode });
                    if (item != null)
                    {
                        itemData.itemPackUnit = item.CN_S_PACK_UNIT;
                        itemData.itemName = item.CN_S_ITEM_NAME;
                    }
                    else
                    {
                        executeInWorkAreaPara.BasisResponse = BasisResponse.Error("物料" + itemData.itemCode + "在AutoBom中没有维护");
                        return executeInWorkAreaPara;
                    }
                }
            }

            if (!string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.endBit))
            {
                executeInWorkAreaPara.EndLocationEntity = DALCreator.Create<TN_WMS_LOCATIONDAL>().GetModel(executeInWorkAreaPara.InWorkAreaEntity.endBit);
                if (executeInWorkAreaPara.EndLocationEntity != null)
                {
                    executeInWorkAreaPara.EndStockAreaEntity = DALCreator.Create<TN_AB_B_STOCK_AREADAL>().GetStockAreaEntity(executeInWorkAreaPara.EndLocationEntity.CN_S_AREA_CODE);
                    if (executeInWorkAreaPara.EndStockAreaEntity == null)
                    {
                        executeInWorkAreaPara.BasisResponse = BasisResponse.Error("结束位置：" + executeInWorkAreaPara.InWorkAreaEntity.endBit + "，库区：" + executeInWorkAreaPara.EndLocationEntity.CN_S_AREA_CODE + "未找到库区信息！");
                        return executeInWorkAreaPara;
                    }
                }
                else
                {
                    executeInWorkAreaPara.BasisResponse = BasisResponse.Error("结束位置：" + executeInWorkAreaPara.InWorkAreaEntity.endBit + "未找到货位信息！");
                    return executeInWorkAreaPara;
                }
                // 检查货位状态  管控数量时使用
                if (executeInWorkAreaPara.EndStockAreaEntity.CN_C_IS_CONTROL_QTY.Equals("Y"))
                {
                    executeInWorkAreaPara.EndLocationExt = BLLCreator.Create<TN_WM_LOCATION_EXTBLL>().GetModel(" where CN_S_LOCATION_CODE = '" + executeInWorkAreaPara.InWorkAreaEntity.endBit.Trim() + "'").FirstOrDefault();

                    //if (executeInWorkAreaPara.InWorkAreaEntity.isControlEndBit.Equals("true"))
                    //{
                    if (!executeInWorkAreaPara.EndLocationExt.CN_S_LOCATION_STATE.Equals("正常"))
                    {
                        executeInWorkAreaPara.BasisResponse = BasisResponse.Error("当前终点货位状态为" + executeInWorkAreaPara.EndLocationExt.CN_S_LOCATION_STATE + "，货位不可用！");
                        return executeInWorkAreaPara;
                    }
                    if (!executeInWorkAreaPara.EndLocationExt.CN_S_USE_STATE.Equals("空"))
                    {
                        executeInWorkAreaPara.BasisResponse = BasisResponse.Error("当前终点货位存储状态为" + executeInWorkAreaPara.EndLocationExt.CN_S_USE_STATE + "，货位不可用！");
                        return executeInWorkAreaPara;
                    }
                    //}

                    //锁定终点货位
                    OperateResult lockResult = BLLCreator.Create<HH.WMS.BLL.Basic.TN_WM_LOCATION_EXTBLL>().UpdateState(executeInWorkAreaPara.InWorkAreaEntity.endBit, "预入库锁定", "正常");
                    if (lockResult.Success && lockResult.AffectedRows > 0)
                    {
                        AutoBomLocationEntity locationModel = DALCreator.Create<TN_WMS_LOCATIONDAL>().GetModel(executeInWorkAreaPara.InWorkAreaEntity.endBit);
                        //添加货位状态变化
                        BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeInWorkAreaPara.InWorkAreaEntity.endBit, "正常", "预入库锁定", "入库并且转运需要锁定终点货位防止其他资源竞争", executeInWorkAreaPara.InWorkAreaEntity.sysName, "", "", locationModel.CN_S_STOCK_CODE, locationModel.CN_S_AREA_CODE, null);
                        executeInWorkAreaPara.RollbackLocations.Add(executeInWorkAreaPara.InWorkAreaEntity.endBit);
                    }
                    else
                    {
                        if (!lockResult.Success)
                        {
                            executeInWorkAreaPara.BasisResponse = BasisResponse.Error("锁定终点货位" + executeInWorkAreaPara.InWorkAreaEntity.endBit + "失败！详细原因为：" + lockResult.Msg);
                        }
                        else
                        {
                            executeInWorkAreaPara.BasisResponse = BasisResponse.Error("锁定终点货位" + executeInWorkAreaPara.InWorkAreaEntity.endBit + "失败！详细原因为：SqlExecuteResult影响行数为0");
                        }
                        return executeInWorkAreaPara;
                    }
                }
            }

            //原料入库时处理
            if (executeInWorkAreaPara.InWorkAreaEntity.trayWeight > 0)
            {
                //判断托盘是否绑定物料，以及托盘是否已经绑定目的库区货位
                var trayItem = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetSingleEntity(new { CN_S_TRAY_CODE = executeInWorkAreaPara.InWorkAreaEntity.trayCode });
                if (trayItem == null)
                {
                    executeInWorkAreaPara.BasisResponse = BasisResponse.Error("空托不能原料入库，原因：托盘" + executeInWorkAreaPara.InWorkAreaEntity.trayCode + "未绑定物料！");
                    return executeInWorkAreaPara;
                }
                executeInWorkAreaPara.InWorkAreaEntity.itemCode = trayItem.CN_S_ITEM_CODE;

                //判断是否是并笼
                var combineCages = BLLCreator.Create<TN_ER_COMBINE_CAGE_HISTORYBLL>().GetList(executeInWorkAreaPara.InWorkAreaEntity.trayCode, "新建");
                if (combineCages.Count() == 0)
                {
                    executeInWorkAreaPara.IsCombineCage = false;
                }
                else
                {
                    executeInWorkAreaPara.IsCombineCage = true;
                    //如果是并笼，删除托盘和货位的关联
                    CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new
                    {
                        CN_S_TRAY_CODE = executeInWorkAreaPara.InWorkAreaEntity.trayCode
                    }, null);
                }
            }
            return executeInWorkAreaPara;
        }

        public override ExecuteInWorkAreaPara InWorkAreaCalculatePath(ref ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            Log.Detail(logPara, "结算路径：");
            //获取作业区列表
            var workAreaProList = BLLCreator.Create<TaskTransferBLL>().GetInWorkPosition(executeInWorkAreaPara);
            if (workAreaProList.Any())
            {
                executeInWorkAreaPara.WorkAreaProEntitys = workAreaProList;

                Log.Detail(logPara, "executeInWorkAreaPara.InWorkAreaEntity.taskType:" + executeInWorkAreaPara.InWorkAreaEntity.taskType);

                if (executeInWorkAreaPara.InWorkAreaEntity.taskType != null)
                {
                    if (executeInWorkAreaPara.InWorkAreaEntity.taskType.Equals("原料入库"))
                    {
                        //判断当前托盘是否已经绑定到目的库区
                        var trayLocations = BLLCreator.Create<DapperBLL<TN_WM_B_TRAY_LOCATIONEntity>>().GetList(new { CN_S_TRAY_CODE = executeInWorkAreaPara.InWorkAreaEntity.trayCode });
                        if (trayLocations.Count() > 0)
                        {
                            var areaCodes = workAreaProList.Select(e=>e.CN_S_END_AREA_CODE);
                            var trayLocationsPara = trayLocations.Where(e => areaCodes.Contains(e.CN_S_STOCK_AREA));
                            if (trayLocationsPara.Count() > 0)
                            {
                                executeInWorkAreaPara.BasisResponse = BasisResponse.Error("当前托盘" + executeInWorkAreaPara.InWorkAreaEntity.trayCode + "已经存在目的库区中，不允许重复入库！");
                                return executeInWorkAreaPara;
                            }
                        }

                        Log.Detail(logPara, "当前托盘executeInWorkAreaPara.InWorkAreaEntity.trayCode：" + executeInWorkAreaPara.InWorkAreaEntity.trayCode);
                        var trayInfo = BLLCreator.Create<TN_WM_B_TRAY_INFOBLL>().GetByTrayCode(executeInWorkAreaPara.InWorkAreaEntity.trayCode);
                        trayInfo.CN_S_USE_STATE = trayInfo.CN_S_USE_STATE.Trim();
                        Log.Detail(logPara, "trayInfo为： " + JsonConvert.SerializeObject(trayInfo));
                        if (trayInfo != null)
                        {
                            if (trayInfo.CN_S_USE_STATE != null)
                            {
                                if (trayInfo.CN_S_USE_STATE.Equals("不满"))
                                {
                                    executeInWorkAreaPara.WorkAreaProEntitys = executeInWorkAreaPara.WorkAreaProEntitys.Where(e => e.CN_S_END_AREA_CODE.Equals("YLBM")).ToList();
                                    Log.Detail(logPara, "原料入库 状态：不满，转运流程为：" + JsonConvert.SerializeObject(executeInWorkAreaPara.WorkAreaProEntitys));
                                }
                                else if (trayInfo.CN_S_USE_STATE.Equals("满"))
                                {
                                    var trayItemMst = BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().GetTrayItemMst(" AND CN_S_TRAY_CODE ='" + executeInWorkAreaPara.InWorkAreaEntity.trayCode + "'");
                                    if (trayItemMst.Count() <= 0)
                                    {
                                        executeInWorkAreaPara.BasisResponse = BasisResponse.Error("原料入库未找到托盘！");
                                        return executeInWorkAreaPara;
                                    }
                                    executeInWorkAreaPara.WorkAreaProEntitys = executeInWorkAreaPara.WorkAreaProEntitys.Where(e => !e.CN_S_END_AREA_CODE.Equals("YLBM")).ToList();
                                    //var item = BLLCreator.Create<HH.WMS.BLL.Basic.TN_WMS_ITEMBLL>().GetItem(trayItemMst.First().CN_S_ITEM_CODE);
                                    //if (item == null)
                                    //{
                                    //    executeInWorkAreaPara.BasisResponse = BasisResponse.Error("未找到物料" + trayItemMst.First().CN_S_ITEM_CODE + "！");
                                    //    return executeInWorkAreaPara;
                                    //}
                                    //if (item.CN_S_FEATURE.Equals("YLENDC")) //放大件的
                                    //{
                                    //    executeInWorkAreaPara.WorkAreaProEntitys = executeInWorkAreaPara.WorkAreaProEntitys.Where(e => e.CN_S_END_AREA_CODE.Equals("YLENDC")).ToList();
                                    //}
                                    //else
                                    //{
                                    //    executeInWorkAreaPara.WorkAreaProEntitys = executeInWorkAreaPara.WorkAreaProEntitys.Where(e => !e.CN_S_END_AREA_CODE.Equals("YLENDC")).ToList();
                                    //}
                                    Log.Detail(logPara, "原料入库 状态：满，转运流程为：" + JsonConvert.SerializeObject(executeInWorkAreaPara.WorkAreaProEntitys));
                                }
                            }
                            else
                            {
                                executeInWorkAreaPara.BasisResponse = BasisResponse.Error("请维护托盘的状态！");
                                return executeInWorkAreaPara;
                            }
                        }
                    }
                }
            }
            else
            {
                executeInWorkAreaPara.BasisResponse = BasisResponse.Error("未找到该库区的作业流转流程！");
                return executeInWorkAreaPara;
            }
            return executeInWorkAreaPara;
        }

        public override ExecuteInWorkAreaPara InWorkAreaInAss(ref ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
             var logicAreaCode = string.Empty;
            if (executeInWorkAreaPara.InWorkAreaEntity.data != null)
            {
                if (executeInWorkAreaPara.InWorkAreaEntity.data.Count() > 0)
                {
                    //根据物料查找逻辑分区
                    if (!string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.data[0].itemCode))
                    {
                        List<AutoBomPartition_Item_REntity> lstLogicEntityByItem = DALCreator.Create<TN_WMS_AREADAL>().GetPartitionItem(executeInWorkAreaPara.InWorkAreaEntity.data[0].itemCode, 2);
                        logicAreaCode = lstLogicEntityByItem.FirstOrDefault() != null ? lstLogicEntityByItem.First().CN_S_AREA_CODE : "";
                    }
                }
            }

            var aEntity = new InAssignEntity()
            {
                objectType = InAssignEntity.ObjectType.托盘,
                objectCode = executeInWorkAreaPara.InWorkAreaEntity.trayCode,
                itemCode = (executeInWorkAreaPara.InWorkAreaEntity.data != null &&
                 executeInWorkAreaPara.InWorkAreaEntity.data.Count > 0)
                    ? executeInWorkAreaPara.InWorkAreaEntity.data[0].itemCode
                    : "",
                lstAreaPrior = executeInWorkAreaPara.WorkAreaProEntitys.Select(p => new areaPriorClass { areaCode = p.CN_S_END_AREA_CODE, Prior = p.CN_N_PRIORITY }).ToList(),
                //lockLocation = endArea != null ? endArea.CN_C_IS_CONTROL_QTY.Equals("Y") : false, //不管控数量时，不锁定目的货位
                projectCode = executeInWorkAreaPara.InWorkAreaEntity.projectCode,
                logicAreaCode = logicAreaCode,
                //taskNo = executeInWorkAreaPara.InWorkAreaEntity.taskNo,
                stockCode = executeInWorkAreaPara.InWorkAreaEntity.startStock,
                callSys = executeInWorkAreaPara.InWorkAreaEntity.sysName,
                needCalLock = true
            };

            //根据库区获取货位
            InAssignResultEntity resultEntity = BLLCreator.Create<In_AlgorBLL>().InAssign(aEntity);
            if (resultEntity.Success)
            {
                executeInWorkAreaPara.TransportEntity.CN_S_QTY_INDEX = resultEntity.index;
                //增加到回滚记录里面
                if ((resultEntity.areaType == Constants.Area_Struc_PingStock || resultEntity.areaType == Constants.Area_Struc_LiStock) && resultEntity.isControlQty == "Y")
                {
                    executeInWorkAreaPara.RollbackLocations.Add(resultEntity.locationCode);
                }

                executeInWorkAreaPara.EndLocationEntity = BLLCreator.Create<TN_AB_STOCK_LOCATIONBLL>().GetLocationModel(resultEntity.locationCode);
                if (executeInWorkAreaPara.EndLocationEntity != null)
                    executeInWorkAreaPara.EndStockAreaEntity = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetStockAreaEntity(executeInWorkAreaPara.EndLocationEntity.CN_S_AREA_CODE);
            }
            else
            {
                executeInWorkAreaPara.BasisResponse = BasisResponse.Error("在" + string.Join(",", executeInWorkAreaPara.WorkAreaProEntitys.Select(o => o.CN_S_END_AREA_CODE).ToList()) + "库区中未找到合适的入库货位,详细原因：" + resultEntity.Msg);
                
                if (!executeInWorkAreaPara.BasisResponse.Success)
                {
                    if (!string.IsNullOrEmpty(executeInWorkAreaPara.InWorkAreaEntity.taskType))
                    {
                        if (executeInWorkAreaPara.InWorkAreaEntity.taskType.Equals("原料入库"))
                        {
                            Log.Detail(logPara, "绑定托盘到虚拟库区！");
                            var trayInfo = BLLCreator.Create<TN_WM_B_TRAY_INFOBLL>().GetByTrayCode(executeInWorkAreaPara.InWorkAreaEntity.trayCode);
                            trayInfo.CN_S_USE_STATE = trayInfo.CN_S_USE_STATE.Trim();
                            var trayLocation = new TN_WM_B_TRAY_LOCATIONEntity()
                            {
                                CN_GUID = Guid.NewGuid().ToString(),
                                CN_N_INDEX = 1,
                                CN_S_CREATOR = "",
                                CN_S_CREATOR_BY = "",
                                CN_S_LOCATION_CODE = "",
                                CN_S_STOCK_AREA = "XN01",   //虚拟存储区
                                CN_S_STOCK_CODE = executeInWorkAreaPara.StartStockAreaEntity.CN_S_STOCK_CODE,
                                CN_S_TRAY_CODE = executeInWorkAreaPara.InWorkAreaEntity.trayCode,
                                CN_T_CREATE = DateTime.Now
                            };

                            if (trayInfo.CN_S_USE_STATE.Equals("不满"))
                            {
                                Log.Detail(logPara, "绑定托盘到货位：HXN-BM-01");
                                trayLocation.CN_S_LOCATION_CODE = "HXN-BM-01";
                            }
                            else if (trayInfo.CN_S_USE_STATE.Equals("满"))
                            {
                                Log.Detail(logPara, "绑定托盘到货位：HXN-MM-01");
                                trayLocation.CN_S_LOCATION_CODE = "HXN-MM-01";
                            }
                            //添加托盘货位
                            CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Add(trayLocation, null);

                            //添加仓库库存
                            var addStockQty = new List<TN_WM_B_STOCK_QTYEntity>();
                            //托盘物料主表
                            var trayItemMsts = CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().GetList(new { trayLocation.CN_S_TRAY_CODE });
                            if (trayItemMsts.Count > 0)
                            {
                                foreach (var trayItemMst in trayItemMsts)
                                {
                                    var trayItemDtls = CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_DTLEntity>>().GetList(new { CN_PARENT_GUID = trayItemMst.CN_GUID });
                                    foreach(var trayItemDtl in trayItemDtls){
                                        addStockQty.Add(new TN_WM_B_STOCK_QTYEntity()
                                        {
                                            CN_S_ITEM_CODE = trayItemMst.CN_S_ITEM_CODE,
                                            CN_S_ITEM_NAME = trayItemMst.CN_S_ITEM_NAME,
                                            CN_S_ITEM_STATE = trayItemMst.CN_S_ITEM_STATE,
                                            CN_S_OWNER = trayItemMst.CN_S_OWNER,
                                            CN_S_PRODUCTION_BATCH = trayItemMst.CN_S_PRODUCTION_BATCH,
                                            CN_S_LOT_NO = trayItemDtl.CN_S_LOT_NO,
                                            CN_F_QUANTITY = trayItemMst.CN_F_QUANTITY,
                                            CN_S_STOCK_CODE = trayLocation.CN_S_STOCK_CODE,
                                            CN_S_STOCK_AREA = trayLocation.CN_S_STOCK_AREA,
                                            CN_F_PLANNED_QTY = trayItemMst.CN_F_INQTY,
                                            CN_S_MODEL = trayItemMst.CN_S_MODEL,
                                            CN_S_FIGURE_NO = trayItemDtl.CN_S_EXT1,
                                            CN_S_MEASURE_UNIT = trayItemMst.CN_S_MEASURE_UNIT
                                        });
                                    }
                                }
                            }
                            CreateDAL<TN_WM_B_STOCK_QTYDAL>().AddStockQty(addStockQty, null);

                            InWorkAreaProcedureItemPound(executeInWorkAreaPara, logPara);
                        }
                    }
                }
            }
            return executeInWorkAreaPara;
        }

        public override ExecuteInWorkAreaPara InWorkAreaProcedure(ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            var result = UseTransaction(trans =>
            {
                InWorkAreaProcedureFunc(executeInWorkAreaPara, trans, logPara);
                if (executeInWorkAreaPara.InWorkAreaEntity.needCreateAMSTask == "Y")
                {
                    OperateResult re = new OtherSysApi().SendAmsCreateTask(executeInWorkAreaPara.TransportEntity);
                    if (!re.Success)
                    {
                        throw new Exception("SendAmsCreateTask异常：" + re.Msg);
                    }
                }


            });
            if (result.Success)
            {
                InWorkAreaProcedureItemPound(executeInWorkAreaPara, logPara);

                executeInWorkAreaPara.TaskExecuteState = new TaskExecuteState().Ok(new OkTask()
                {
                    index = executeInWorkAreaPara.index,
                    taskNo = executeInWorkAreaPara.TransportEntity.CN_S_TASK_NO,
                    startStock = executeInWorkAreaPara.TransportEntity.CN_S_STOCK_CODE,
                    startArea = executeInWorkAreaPara.TransportEntity.CN_S_START_AREA,
                    startBit = executeInWorkAreaPara.TransportEntity.CN_S_START_BIT,
                    endStock = executeInWorkAreaPara.TransportEntity.CN_S_STOCK_CODE,
                    endArea = executeInWorkAreaPara.TransportEntity.CN_S_END_AREA,
                    endBit = executeInWorkAreaPara.TransportEntity.CN_S_END_BIT,
                    priority = executeInWorkAreaPara.TransportEntity.CN_N_PRIORITY,
                    trayCode = executeInWorkAreaPara.TransportEntity.CN_S_CIR_OBJ_CODE,
                    startAreaClass = executeInWorkAreaPara.TransportEntity.CN_S_START_AREA_TYPE,
                    endAreaClass = executeInWorkAreaPara.TransportEntity.CN_S_END_AREA_TYPE,
                    itemCode = executeInWorkAreaPara.InWorkAreaEntity.itemCode
                });
            }
            else
            {
                executeInWorkAreaPara.BasisResponse = BasisResponse.Error("ExecuteInWorkArea 方法异常：" + result.Msg);
            }
            return executeInWorkAreaPara;
        }

        /// <summary>
        /// 原料入库 处理小磅单
        /// </summary>
        public void InWorkAreaProcedureItemPound(ExecuteInWorkAreaPara executeInWorkAreaPara, LogPara logPara)
        {
            //创建小榜单
            if (executeInWorkAreaPara.InWorkAreaEntity.trayWeight > 0)
            {
                Log.Detail(logPara, "原料入库 处理小磅单");

                //检查是否是并笼
                if (executeInWorkAreaPara.IsCombineCage)
                {
                    var combineCages = BLLCreator.Create<TN_ER_COMBINE_CAGE_HISTORYBLL>().GetList(executeInWorkAreaPara.InWorkAreaEntity.trayCode, "新建");
                    //是否更新小磅单主笼、从笼的重量和数量
                    foreach (var combineCage in combineCages)
                    {
                        if (combineCage.CN_S_MAIN_TRAY_CODE.Equals(combineCage.CN_S_TRAY_CODE))
                        {
                            //主笼 更新重量和数量
                            BLLCreator.Create<TN_ER_ITEM_POUNDBLL>().UpdateWeightAndQty(combineCage.CN_S_POUND_NO, combineCage.CN_S_TRAY_CODE, executeInWorkAreaPara.InWorkAreaEntity.trayWeight, combineCage.CN_F_QTY, null, logPara);
                        }
                        else
                        {
                            //从笼
                            BLLCreator.Create<TN_ER_ITEM_POUNDBLL>().UpdateWeightAndQty(combineCage.CN_S_POUND_NO, combineCage.CN_S_TRAY_CODE, 0, 0, null, logPara);
                        }
                    }
                }
                else
                {
                    //不是并笼，则创建小磅单                    
                    //获取AUTOBOM小磅单号
                    var postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.Rule_ItemPound + "\",\"orgId\":\"0\",\"orgFlag\":\"\"}";
                    var itemPoundNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);
                    BLLCreator.Create<TN_ER_ITEM_POUNDBLL>().Add(executeInWorkAreaPara.InWorkAreaEntity.trayCode, executeInWorkAreaPara.InWorkAreaEntity.trayWeight, executeInWorkAreaPara.TransportEntity.CN_S_TASK_NO, null);
                }
            }
        }

        #endregion

        #region 出库

        public override ExternalResponse OutWorkArea(List<OutWorkAreaEntity> outWorkAreaList, LogPara logPara)
        {
            Log.Detail(logPara, "OutWorkArea接口请求参数：" + JsonConvert.SerializeObject(outWorkAreaList));
            var response = new ExternalResponse();
            if (outWorkAreaList == null) return new ExternalResponse { success = false, errCode = "102", errMsg = "参数不正确" };
            if (outWorkAreaList.Count() == 0) return new ExternalResponse { success = false, errCode = "102", errMsg = "参数不正确" };
            if (string.IsNullOrEmpty(outWorkAreaList[0].sysName))
            {
                outWorkAreaList[0].sysName = "AMS";
            }
            var result = OutWorkArea(outWorkAreaList[0], logPara);
            if (result.BasisResponse.Success)
            {
                response.success = true;
                response.okList.Add(result.TaskExecuteState.okTask);
                response.errCode = "100";
                //发送到AMS
                //SendToAms(response, logPara);
            }
            else
            {
                if (result.BasisResponse.Message.Contains("算法返回结果"))
                {
                    response.errCode = "203";
                    response.errMsg = result.BasisResponse.Message;
                }
                response.failList.Add(new TaskExecuteState().Error(0, result.BasisResponse.Message).FailTask);
                if (result.RollLocations.Count > 0)
                {
                    foreach (string sLocation in result.RollLocations)
                    {
                        BLLCreator.Create<TN_WM_LOCATION_EXTBLL>().UpdateState(sLocation, Constants.Location_State_Normal, "");
                        AutoBomLocationEntity locationModel = CreateDAL<TN_WMS_LOCATIONDAL>().GetModel(sLocation);
                        BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(sLocation, "", "正常", "出库请求失败回滚过程中锁定的货位", outWorkAreaList[0].sysName, "", "", locationModel.CN_S_STOCK_CODE, locationModel.CN_S_AREA_CODE, null);
                    }
                }
            }

            var curResult = response.failList.Any() ? response.Error(null, string.Empty, outWorkAreaList) : response.Ok(null, outWorkAreaList);
            Log.Detail(logPara, "OutWorkArea接口返回参数：" + curResult);
            return curResult;
        }

        public override ExecuteOutWorkAreaPara OutWorkAreaVerifyPara(ref ExecuteOutWorkAreaPara executeOutWorkAreaPara, LogPara logPara)
        {
            base.OutWorkAreaVerifyPara(ref executeOutWorkAreaPara, logPara);
            if (!executeOutWorkAreaPara.BasisResponse.Success) return executeOutWorkAreaPara;

            var produceLineMapStr = JsonHelper.GetValue("produceLineMapping");
            List<ProduceLineMapDto> produceLineMaps = JsonConvert.DeserializeObject<List<ProduceLineMapDto>>(produceLineMapStr);
            foreach (var produceLineMap in produceLineMaps)
            {
                if (produceLineMap.locationCode.Equals(executeOutWorkAreaPara.OutWorkAreaEntity.endBit))
                {
                    executeOutWorkAreaPara.OutWorkAreaEntity.produceLine = produceLineMap.produceLine;
                    if (!string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.produceLine))
                    {
                        var materialStockOuts = BLLCreator.Create<MiddleLibraryBLL>().GetMaterialStockOut(executeOutWorkAreaPara.OutWorkAreaEntity.produceLine);
                        if (materialStockOuts.Count() <= 0)
                        {
                            executeOutWorkAreaPara.BasisResponse = BasisResponse.Error("未找到产线" + executeOutWorkAreaPara.OutWorkAreaEntity.produceLine + "且状态为开工的料单！");
                            return executeOutWorkAreaPara;
                        }
                        executeOutWorkAreaPara.OutWorkAreaEntity.Data = new List<OutWorkDataEntity>();
                        executeOutWorkAreaPara.OutWorkAreaEntity.Data.Add(new OutWorkDataEntity
                        {
                            ItemCode = materialStockOuts.First().CN_S_ITEM_CODE
                        });
                        executeOutWorkAreaPara.OutWorkAreaEntity.itemCode = materialStockOuts.First().CN_S_ITEM_CODE;
                    }
                }
            }


            //var endBits = new Dictionary<string, string> { { "HCX01", "1" }, { "HCX02", "2" }, { "HCX03", "3" }, { "HCX04", "4" } };
            //if (endBits.ContainsKey(executeOutWorkAreaPara.OutWorkAreaEntity.endBit))
            //{
              
            //}
            //当前不穿传生产线
            //if (executeOutWorkAreaPara.OutWorkAreaEntity.produceLine != null)
            //{ }

            return executeOutWorkAreaPara;
        }

        public override ExecuteOutWorkAreaPara OutWorkAreaCreateTask(ref ExecuteOutWorkAreaPara executeOutWorkAreaPara, LogPara logPara)
        {
            if (!executeOutWorkAreaPara.BasisResponse.Success) return executeOutWorkAreaPara;

            //生成原料出库明细
            if (!string.IsNullOrEmpty(executeOutWorkAreaPara.OutWorkAreaEntity.produceLine))
            {
                var task = executeOutWorkAreaPara.TransportList.FirstOrDefault();
                var result = BLLCreator.Create<TN_ER_MATERIAL_STOCKOUT_DTLBLL>().Add(task.CN_S_CIR_OBJ_CODE, executeOutWorkAreaPara.OutWorkAreaEntity.produceLine, task.CN_S_TASK_NO, task.CN_S_STOCK_CODE, logPara, -1);
                if (!result.Success)
                {
                    executeOutWorkAreaPara.BasisResponse = BasisResponse.Error(result.Msg);
                    return executeOutWorkAreaPara;
                }
            }

            executeOutWorkAreaPara = base.OutWorkAreaCreateTask(ref executeOutWorkAreaPara, logPara);
            return executeOutWorkAreaPara;
        }

        #endregion

        #region 完工回报

        public override OperateResult CompleteTask(ExecuteStateParaDto executeStatePara, LogPara logPara)
        {
            var isControlStockQty = executeStatePara.trayItemMsts.Count > 0;
            Log.Detail(logPara, "isControlStockQty: " + isControlStockQty);

            #region 组合量表参数

            //获取上架量=总量-分配量
            //var trayInventory = CreateDAL<TN_WM_B_TRAY_ITEM_RELDAL>().GetTrayInventoryQty(executeStatePara.transportTask.CN_S_TRAY_CODE);
            var addAreaQty = new List<TN_WM_B_AREA_QTYEntity>();
            var addStockQty = new List<TN_WM_B_STOCK_QTYEntity>();

            if (isControlStockQty)
            {
                foreach (var trayItemMst in executeStatePara.trayItemMsts)
                {
                    foreach (var trayItemDtl in trayItemMst.TrayItemDtlList)
                    {
                        addAreaQty.Add(new TN_WM_B_AREA_QTYEntity()
                        {
                            CN_S_ITEM_CODE = trayItemMst.CN_S_ITEM_CODE,
                            CN_S_ITEM_NAME = trayItemMst.CN_S_ITEM_NAME,
                            CN_S_ITEM_STATE = trayItemMst.CN_S_ITEM_STATE,
                            CN_S_OWNER = trayItemMst.CN_S_OWNER,
                            CN_S_PRODUCTION_BATCH = trayItemMst.CN_S_PRODUCTION_BATCH,
                            CN_S_LOT_NO = trayItemDtl.CN_S_LOT_NO,
                            CN_F_QUANTITY = trayItemMst.CN_F_QUANTITY,
                            CN_S_STOCK_CODE = executeStatePara.transportTask.CN_S_STOCK_CODE,
                            CN_F_PLANNED_QTY = 0,
                            CN_S_MODEL = trayItemMst.CN_S_MODEL,
                            CN_S_MEASURE_UNIT = trayItemMst.CN_S_MEASURE_UNIT,
                            CN_S_FIGURE_NO = trayItemDtl.CN_S_EXT1
                        });

                        addStockQty.Add(new TN_WM_B_STOCK_QTYEntity()
                        {
                            CN_S_ITEM_CODE = trayItemMst.CN_S_ITEM_CODE,
                            CN_S_ITEM_NAME = trayItemMst.CN_S_ITEM_NAME,
                            CN_S_ITEM_STATE = trayItemMst.CN_S_ITEM_STATE,
                            CN_S_OWNER = trayItemMst.CN_S_OWNER,
                            CN_S_PRODUCTION_BATCH = trayItemMst.CN_S_PRODUCTION_BATCH,
                            CN_S_LOT_NO = trayItemDtl.CN_S_LOT_NO,
                            CN_F_QUANTITY = trayItemMst.CN_F_QUANTITY,
                            CN_S_STOCK_CODE = executeStatePara.transportTask.CN_S_STOCK_CODE,
                            CN_S_STOCK_AREA = executeStatePara.transportTask.CN_S_END_AREA,
                            CN_F_PLANNED_QTY = 0,
                            CN_S_MODEL = trayItemMst.CN_S_MODEL,
                            CN_S_FIGURE_NO = trayItemDtl.CN_S_EXT1,
                            CN_S_MEASURE_UNIT = trayItemMst.CN_S_MEASURE_UNIT
                        });
                    }
                }
                Log.Detail(logPara, LogDescribe.Content(addAreaQty));
                Log.Detail(logPara, LogDescribe.Content(addStockQty));
            }

            #endregion

            var transResult = UseTransaction(trans =>
            {
                //更新任务状态
                CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                {
                    CN_S_MODIFY = "",
                    CN_S_MODIFY_BY = "",
                    CN_T_END = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_STATE = executeStatePara.taskState
                }, new { executeStatePara.transportTask.CN_S_TASK_NO }, trans);
                Log.Detail(logPara, "更新任务状态-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO + "状态为：" + executeStatePara.taskState);

                #region 入库 + 转运

                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("入库") || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                {
                    CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new {
                        executeStatePara.transportTask.CN_S_TRAY_CODE,
                        CN_S_STOCK_AREA = "XN01"
                    });

                    var trayLocation = new TN_WM_B_TRAY_LOCATIONEntity()
                    {
                        CN_GUID = Guid.NewGuid().ToString(),
                        CN_N_INDEX = 1,
                        CN_S_CREATOR = "",
                        CN_S_CREATOR_BY = "",
                        CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT,
                        CN_S_STOCK_AREA = executeStatePara.transportTask.CN_S_END_AREA,
                        CN_S_STOCK_CODE = executeStatePara.transportTask.CN_S_STOCK_CODE,
                        CN_S_TRAY_CODE = executeStatePara.transportTask.CN_S_TRAY_CODE,
                        CN_T_CREATE = DateTime.Now
                    };

                    if (executeStatePara.startTrayLocation != null)
                    {
                        //解绑托盘与货位的关系
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new
                        {
                            executeStatePara.transportTask.CN_S_TRAY_CODE,
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);
                        Log.Detail(logPara, "解绑任务的托盘和起点货位关联！");

                        #region 下架记录

                        if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                        {
                            CompleteTaskDownHistory(executeStatePara, logPara, trans);
                        }

                        if (executeStatePara.transportTask.CN_S_START_CONTROL_INV.Equals("Y") && executeStatePara.transportTask.CN_S_START_AREA != executeStatePara.transportTask.CN_S_END_AREA)  //降低起点库存
                        {
                            CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_START_AREA, logPara, trans);
                        }

                        #endregion
                    }

                    if (executeStatePara.endTrayLocation == null)
                    {
                        //添加托盘货位
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Add(trayLocation, trans);
                        Log.Detail(logPara, "添加托盘货位关联，内容：" + LogDescribe.Content(trayLocation));

                        if (isControlStockQty)
                        {
                            #region 添加上架记录，升库存

                            CompleteTaskUpHistory(executeStatePara, logPara, trans);


                            if (string.IsNullOrEmpty(executeStatePara.transportTask.CN_S_END_CONTROL_INV))
                            {
                                trans.Rollback();
                                return;
                            }

                            if (executeStatePara.transportTask.CN_S_END_CONTROL_INV.Equals("Y") && executeStatePara.transportTask.CN_S_START_AREA != executeStatePara.transportTask.CN_S_END_AREA) //如果起点和终点在一个库区，不增加
                            {
                                //按未入库量增加结束库区量
                                CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_END_AREA, logPara, trans);
                                if (!executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                                {
                                    //升仓库库存
                                    CreateDAL<TN_WM_B_STOCK_QTYDAL>().AddStockQty(addStockQty, trans);
                                    Log.Detail(logPara, "增加仓库库存！");
                                }
                            }

                            #endregion
                        }

                        //终点
                        if (executeStatePara.endIsCurrentTask != null && executeStatePara.transportTask.CN_C_END_IS_CONTROL_QTY.Equals("Y"))
                        {
                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_END_BIT, "正常", "满", "预入库锁定", trans);
                            Log.Detail(logPara, "更新预入库锁定的货位状态为正常、满，货位号：" + executeStatePara.transportTask.CN_S_END_BIT);

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_END_BIT, "预入库锁定", "正常", "状态回报入库完成-终点", "", "", "", executeStatePara.endStockArea.CN_S_STOCK_CODE, executeStatePara.endStockArea.CN_S_AREA_CODE, trans);
                        }

                        //起点
                        if (executeStatePara.transportTask.CN_C_START_IS_CONTROL_QTY.Equals("Y") && executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                        {
                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_START_BIT, "正常", "空", "预出库锁定", trans);
                            Log.Detail(logPara, "更新预出库锁定的货位状态为正常、空，起点货位号：" + executeStatePara.transportTask.CN_S_START_BIT);

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_START_BIT, "预出库锁定", "正常", "状态回报转运完成-起点", "", "", "", executeStatePara.startStockArea.CN_S_STOCK_CODE, executeStatePara.startStockArea.CN_S_AREA_CODE, trans);
                        }
                    }
                }

                #endregion

                #region 改道

                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("改道"))
                {
                    CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new
                    {
                        executeStatePara.transportTask.CN_S_TRAY_CODE,
                        CN_S_STOCK_AREA = "XN01"
                    });

                    //清除托盘和物料
                    CreateDAL<DapperDAL<TN_WM_B_TRAY_ITEM_MSTEntity>>().Delete(new { CN_S_TRAY_CODE = executeStatePara.transportTask.CN_S_TRAY_CODE });

                    var trayLocation = new TN_WM_B_TRAY_LOCATIONEntity()
                    {
                        CN_GUID = Guid.NewGuid().ToString(),
                        CN_N_INDEX = 1,
                        CN_S_CREATOR = "",
                        CN_S_CREATOR_BY = "",
                        CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT,
                        CN_S_STOCK_AREA = executeStatePara.transportTask.CN_S_END_AREA,
                        CN_S_STOCK_CODE = executeStatePara.transportTask.CN_S_STOCK_CODE,
                        CN_S_TRAY_CODE = executeStatePara.transportTask.CN_S_TRAY_CODE,
                        CN_T_CREATE = DateTime.Now
                    };

                    if (executeStatePara.startTrayLocation != null)
                    {
                        //解绑托盘与货位的关系
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new
                        {
                            executeStatePara.transportTask.CN_S_TRAY_CODE,
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);
                        Log.Detail(logPara, "解绑任务的托盘和起点货位关联！");

                        #region 下架记录

                        if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("改道"))
                        {
                            CompleteTaskDownHistory(executeStatePara, logPara, trans);
                        }

                        //if (executeStatePara.transportTask.CN_S_START_CONTROL_INV.Equals("Y") && executeStatePara.transportTask.CN_S_START_AREA != executeStatePara.transportTask.CN_S_END_AREA)  //降低起点库存
                        //{
                        //    CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_START_AREA, logPara, trans);
                        //}

                        #endregion
                    }

                    if (executeStatePara.endTrayLocation == null)
                    {
                        //if (executeStatePara.endStockArea.CN_C_IS_CONTROL_QTY.Equals("Y"))
                        //{

                        //}

                        //添加托盘货位绑定 改道不绑定托盘货位
                        //CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Add(trayLocation, trans);
                        //Log.Detail(logPara, "添加托盘货位关联，内容：" + LogDescribe.Content(trayLocation));

                        if (isControlStockQty)
                        {
                            #region 添加上架记录，升库存

                            CompleteTaskUpHistory(executeStatePara, logPara, trans);


                            //if (string.IsNullOrEmpty(executeStatePara.transportTask.CN_S_END_CONTROL_INV))
                            //{
                            //    trans.Rollback();
                            //    return;
                            //}

                            //if (executeStatePara.transportTask.CN_S_END_CONTROL_INV.Equals("Y") && executeStatePara.transportTask.CN_S_START_AREA != executeStatePara.transportTask.CN_S_END_AREA) //如果起点和终点在一个库区，不增加
                            //{
                            //    //按未入库量增加结束库区量
                            //    CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_END_AREA, logPara, trans);
                            //    if (!executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                            //    {
                            //        //升仓库库存
                            //        CreateDAL<TN_WM_B_STOCK_QTYDAL>().AddStockQty(addStockQty, trans);
                            //        Log.Detail(logPara, "增加仓库库存！");
                            //    }
                            //}

                            #endregion
                        }

                        //终点
                        if (executeStatePara.endIsCurrentTask != null && executeStatePara.transportTask.CN_C_END_IS_CONTROL_QTY.Equals("Y"))
                        {
                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_END_BIT, "正常", "满", "预入库锁定", trans);
                            Log.Detail(logPara, "更新预入库锁定的货位状态为正常、满，货位号：" + executeStatePara.transportTask.CN_S_END_BIT);

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_END_BIT, "预入库锁定", "正常", "状态回报入库完成-终点", "", "", "", executeStatePara.endStockArea.CN_S_STOCK_CODE, executeStatePara.endStockArea.CN_S_AREA_CODE, trans);
                        }

                        //起点
                        if (executeStatePara.transportTask.CN_C_START_IS_CONTROL_QTY.Equals("Y") && executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                        {
                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_START_BIT, "正常", "空", "预出库锁定", trans);
                            Log.Detail(logPara, "更新预出库锁定的货位状态为正常、空，起点货位号：" + executeStatePara.transportTask.CN_S_START_BIT);

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_START_BIT, "预出库锁定", "正常", "状态回报转运完成-起点", "", "", "", executeStatePara.startStockArea.CN_S_STOCK_CODE, executeStatePara.startStockArea.CN_S_AREA_CODE, trans);
                        }
                    }

                    //改道后，添加领料单
                    var produceLine = "";

                    var produceLineMapStr = JsonHelper.GetValue("produceLineMapping");
                    List<ProduceLineMapDto> produceLineMaps = JsonConvert.DeserializeObject<List<ProduceLineMapDto>>(produceLineMapStr);
                    foreach (var produceLineMap in produceLineMaps)
                    {
                        if (produceLineMap.locationCode.Equals(executeStatePara.transportTask.CN_S_END_BIT))
                        {
                            produceLine = produceLineMap.produceLine;
                        }
                    }

                    if (!string.IsNullOrEmpty(produceLine))
                    {
                        var result = BLLCreator.Create<TN_ER_MATERIAL_STOCKOUT_DTLBLL>().Add(executeStatePara.transportTask.CN_S_TRAY_CODE,
                            produceLine, executeStatePara.transportTask.CN_S_TASK_NO, executeStatePara.transportTask.CN_S_STOCK_CODE, logPara);
                    }
                }

                #endregion

                #region 出库

                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("出库"))
                {
                    if (executeStatePara.startTrayLocation != null)
                    {
                        BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().Delete(executeStatePara.transportTask.CN_S_TRAY_CODE, executeStatePara.transportTask.CN_S_START_BIT, trans, logPara);
                        BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().Delete(" CN_S_TRAY_CODE='" + executeStatePara.transportTask.CN_S_TRAY_CODE + "' ", trans, logPara);

                        if (isControlStockQty)
                        {
                            #region 添加下架记录，降库存

                            CompleteTaskDownHistory(executeStatePara, logPara, trans);

                            if (executeStatePara.transportTask.CN_S_START_CONTROL_INV.Equals("Y"))
                            {
                                BLLCreator.Create<TN_WM_B_AREA_QTYBLL>().ReduceQtyAndAlloc(addAreaQty, executeStatePara.transportTask.CN_S_START_AREA, trans, logPara);
                                if (!executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                                    BLLCreator.Create<TN_WM_B_STOCK_QTYBLL>().ReduceQtyAndAlloc(addStockQty, trans, logPara);
                            }

                            #endregion
                        }

                        if (executeStatePara.startIsCurrentTask != null && executeStatePara.transportTask.CN_C_START_IS_CONTROL_QTY.Equals("Y"))
                        {
                            BLLCreator.Create<TN_WM_TASKBLL>().UpdateState(executeStatePara.transportTask.CN_S_START_BIT, "正常", "空", "预出库锁定", trans, logPara);
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_START_BIT, "预出库锁定", "正常", "状态回报出库完成", "", "", "", executeStatePara.endStockArea.CN_S_STOCK_CODE, executeStatePara.endStockArea.CN_S_AREA_CODE, trans);
                        }
                    }
                }

                #endregion

                #region 上架

                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("上架"))
                {
                    var trayLocation = new TN_WM_B_TRAY_LOCATIONEntity()
                    {
                        CN_GUID = Guid.NewGuid().ToString(),
                        CN_N_INDEX = 1,
                        CN_S_CREATOR = "",
                        CN_S_CREATOR_BY = "",
                        CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT,
                        CN_S_STOCK_AREA = executeStatePara.transportTask.CN_S_END_AREA,
                        CN_S_STOCK_CODE = executeStatePara.transportTask.CN_S_STOCK_CODE,
                        CN_S_TRAY_CODE = executeStatePara.transportTask.CN_S_TRAY_CODE,
                        CN_T_CREATE = DateTime.Now
                    };

                    if (executeStatePara.endTrayLocation == null)
                    {
                        //添加托盘货位
                        var addResult = BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().Add(trayLocation, trans, logPara);
                        Log.Detail(logPara, "添加托盘货位结果：" + JsonConvert.SerializeObject(addResult));
                        //CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Add(trayLocation, trans);

                        if (isControlStockQty)
                        {
                            //获取配置是否启用收货区
                            var strategyValue = BLLCreator.Create<DapperBaseBLL>().GetStrategy(executeStatePara.transportTask.CN_S_STOCK_CODE, StrategyKey.AreaQtyReceiveGood);

                            #region 添加上架记录，升库存

                            CompleteTaskUpHistory(executeStatePara, logPara, trans);

                            if (string.IsNullOrEmpty(executeStatePara.transportTask.CN_S_END_CONTROL_INV))
                            {
                                trans.Rollback();
                                return;
                            }

                            //启用收货区
                            if (strategyValue.Equals(Constants.Y))
                            {
                                Log.Detail(logPara, "启用收货区！");

                                //降低起始库区（收货区）库存
                                CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_START_AREA, logPara, trans);
                                if (executeStatePara.transportTask.CN_S_END_CONTROL_INV.Equals("Y"))
                                {
                                    //增加结束库区量
                                    CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_END_AREA, logPara, trans);
                                }
                            }
                            else
                            {
                                if (executeStatePara.transportTask.CN_S_END_CONTROL_INV.Equals("Y"))
                                {
                                    //按未入库量增加结束库区量
                                    CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_END_AREA, logPara, trans);
                                    if (!executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                                    {
                                        //升仓库库存
                                        CreateDAL<TN_WM_B_STOCK_QTYDAL>().AddStockQty(addStockQty, trans);
                                        Log.Detail(logPara, "增加仓库量表完成！");
                                    }
                                }
                            }

                            #endregion
                        }

                        if (executeStatePara.endIsCurrentTask != null && executeStatePara.transportTask.CN_C_END_IS_CONTROL_QTY.Equals("Y"))
                        {
                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_END_BIT, "正常", "满", "预入库锁定", trans);
                            Log.Detail(logPara, "更新预入库锁定的货位状态为正常、满，终点货位号：" + executeStatePara.transportTask.CN_S_END_BIT);

                            ////更新终点货位的任务号
                            //CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_TASK_NO = "" }, new { CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT }, trans);
                            //Log.Detail(logPara, "更新终点货位" + executeStatePara.transportTask.CN_S_END_BIT + "的绑定任务号为空！");

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_END_BIT, "预入库锁定", "正常", "状态回报上架完成-终点", "", "", "", executeStatePara.endStockArea.CN_S_STOCK_CODE, executeStatePara.endStockArea.CN_S_AREA_CODE, trans);
                        }

                        if (executeStatePara.transportTask.CN_C_START_IS_CONTROL_QTY.Equals("Y"))
                        {
                            //解绑托盘与货位的关系
                            CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new
                            {
                                executeStatePara.transportTask.CN_S_TRAY_CODE,
                                CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                            }, trans);
                            Log.Detail(logPara, "解绑任务的托盘和起点货位" + executeStatePara.transportTask.CN_S_START_BIT + "关联！");

                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_START_BIT, "正常", "空", "预出库锁定", trans);
                            Log.Detail(logPara, "更新预出库锁定的货位状态为正常、空，起点货位号：" + executeStatePara.transportTask.CN_S_START_BIT);

                            ////更新起点货位的任务号
                            //CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_TASK_NO = "" }, new { CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT });
                            //Log.Detail(logPara, "更新起点货位" + executeStatePara.transportTask.CN_S_START_BIT + "的绑定任务号为空！");

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_START_BIT, "预出库锁定", "正常", "状态回报上架完成-起点", "", "", "", executeStatePara.startStockArea.CN_S_STOCK_CODE, executeStatePara.startStockArea.CN_S_AREA_CODE, trans);
                        }
                    }
                }

                #endregion

                #region 下架/叫料

                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("下架") || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("叫料"))
                {
                    if (executeStatePara.startTrayLocation != null)
                    {
                        BLLCreator.Create<TN_WM_B_TRAY_LOCATIONBLL>().Delete(executeStatePara.transportTask.CN_S_TRAY_CODE, executeStatePara.transportTask.CN_S_START_BIT, trans, logPara);
                        if (executeStatePara.endStockArea.CN_C_IS_CONTROL_QTY.Equals("N"))
                        {
                            BLLCreator.Create<TN_WM_B_TRAY_ITEM_RELBLL>().Delete(" CN_S_TRAY_CODE='" + executeStatePara.transportTask.CN_S_TRAY_CODE + "' ", trans, logPara);
                        }

                        if (isControlStockQty)
                        {
                            #region 添加下架记录，降库存

                            CompleteTaskDownHistory(executeStatePara, logPara, trans);

                            //获取配置是否启用收货区
                            var strategyValue = BLLCreator.Create<DapperBaseBLL>().GetStrategy(executeStatePara.transportTask.CN_S_STOCK_CODE, StrategyKey.AreaQtyDeliverGood);

                            if (strategyValue.Equals(Constants.Y))
                            {
                                if (executeStatePara.transportTask.CN_S_START_CONTROL_INV.Equals("Y"))
                                {
                                    CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_START_AREA, logPara, trans);
                                }

                                //增加终点库区（收货区）库存
                                CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_END_AREA, logPara, trans);
                            }
                            else
                            {
                                if (executeStatePara.transportTask.CN_S_START_CONTROL_INV.Equals("Y"))
                                {
                                    BLLCreator.Create<TN_WM_B_AREA_QTYBLL>().ReduceQtyAndAlloc(addAreaQty, executeStatePara.transportTask.CN_S_START_AREA, trans, logPara);
                                    if (!executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                                        BLLCreator.Create<TN_WM_B_STOCK_QTYBLL>().ReduceQtyAndAlloc(addStockQty, trans, logPara);
                                }
                            }

                            #endregion
                        }

                        if (executeStatePara.startIsCurrentTask != null && executeStatePara.transportTask.CN_C_START_IS_CONTROL_QTY.Equals("Y"))
                        {
                            BLLCreator.Create<TN_WM_TASKBLL>().UpdateState(executeStatePara.transportTask.CN_S_START_BIT, "正常", "空", "预出库锁定", trans, logPara);
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_START_BIT, "预出库锁定", "正常", "状态回报下架完成-起点", "", "", "", executeStatePara.startStockArea.CN_S_STOCK_CODE, executeStatePara.startStockArea.CN_S_AREA_CODE, trans);
                        }

                        if (executeStatePara.transportTask.CN_C_END_IS_CONTROL_QTY.Equals("Y"))
                        {
                            var trayLocation = new TN_WM_B_TRAY_LOCATIONEntity()
                            {
                                CN_GUID = Guid.NewGuid().ToString(),
                                CN_N_INDEX = 1,
                                CN_S_CREATOR = "",
                                CN_S_CREATOR_BY = "",
                                CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT,
                                CN_S_STOCK_AREA = executeStatePara.transportTask.CN_S_END_AREA,
                                CN_S_STOCK_CODE = executeStatePara.transportTask.CN_S_STOCK_CODE,
                                CN_S_TRAY_CODE = executeStatePara.transportTask.CN_S_TRAY_CODE,
                                CN_T_CREATE = DateTime.Now
                            };
                            //添加托盘货位
                            CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Add(trayLocation, trans);

                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_END_BIT, "正常", "满", "预入库锁定", trans);
                            Log.Detail(logPara, "更新预入库锁定的货位状态为正常、满，结束货位号：" + executeStatePara.transportTask.CN_S_END_BIT);

                            ////更新终点货位的任务号
                            //CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_TASK_NO = "" }, new { CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT });
                            //Log.Detail(logPara, "更新终点货位" + executeStatePara.transportTask.CN_S_END_BIT + "的绑定任务号为空！");

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_END_BIT, "预入库锁定", "正常", "状态回报下架完成-终点", "", "", "", executeStatePara.endStockArea.CN_S_STOCK_CODE, executeStatePara.endStockArea.CN_S_AREA_CODE, trans);
                        }
                    }
                }

                #endregion

                #region 空托入（上架）
                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("空托入"))
                {
                    Log.Detail(logPara, "开始执行空托入！");
                    var trayLocation = new TN_WM_B_TRAY_LOCATIONEntity()
                    {
                        CN_GUID = Guid.NewGuid().ToString(),
                        CN_N_INDEX = 1,
                        CN_S_CREATOR = "",
                        CN_S_CREATOR_BY = "",
                        CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT,
                        CN_S_STOCK_AREA = executeStatePara.transportTask.CN_S_END_AREA,
                        CN_S_STOCK_CODE = executeStatePara.transportTask.CN_S_STOCK_CODE,
                        CN_S_TRAY_CODE = executeStatePara.transportTask.CN_S_TRAY_CODE,
                        CN_T_CREATE = DateTime.Now
                    };
                    Log.Detail(logPara, "endTrayLocation: " + JsonConvert.SerializeObject(executeStatePara.endTrayLocation));
                    if (executeStatePara.endTrayLocation == null)
                    {
                        //添加托盘货位
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Add(trayLocation, trans);

                        if (isControlStockQty)
                        {
                            //获取配置是否启用收货区
                            var strategyValue = BLLCreator.Create<DapperBaseBLL>().GetStrategy(executeStatePara.transportTask.CN_S_STOCK_CODE, StrategyKey.AreaQtyReceiveGood);

                            #region 添加上架记录，升库存

                            CompleteTaskUpHistory(executeStatePara, logPara, trans);

                            if (string.IsNullOrEmpty(executeStatePara.transportTask.CN_S_END_CONTROL_INV))
                            {
                                trans.Rollback();
                                return;
                            }

                            //启用收货区
                            if (strategyValue.Equals(Constants.Y))
                            {
                                Log.Detail(logPara, "启用收货区！");

                                //降低起始库区（收货区）库存
                                CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_START_AREA, logPara, trans);
                                if (executeStatePara.transportTask.CN_S_END_CONTROL_INV.Equals("Y"))
                                {
                                    //增加结束库区量
                                    CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_END_AREA, logPara, trans);
                                }
                            }
                            else
                            {
                                if (executeStatePara.transportTask.CN_S_END_CONTROL_INV.Equals("Y"))
                                {
                                    //按未入库量增加结束库区量
                                    CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_END_AREA, logPara, trans);
                                    if (!executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                                    {
                                        //升仓库库存
                                        CreateDAL<TN_WM_B_STOCK_QTYDAL>().AddStockQty(addStockQty, trans);
                                        Log.Detail(logPara, "增加仓库量表完成！");
                                    }
                                }
                            }

                            #endregion
                        }

                        if (executeStatePara.endIsCurrentTask != null && executeStatePara.transportTask.CN_C_END_IS_CONTROL_QTY.Equals("Y"))
                        {
                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_END_BIT, "正常", "满", "预入库锁定", trans);
                            Log.Detail(logPara, "更新预入库锁定的货位状态为正常、满，终点货位号：" + executeStatePara.transportTask.CN_S_END_BIT);

                            ////更新终点货位的任务号
                            //CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_TASK_NO = "" }, new { CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT });
                            //Log.Detail(logPara, "更新终点货位" + executeStatePara.transportTask.CN_S_END_BIT + "的绑定任务号为空！");

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_END_BIT, "预入库锁定", "正常", "状态回报上架完成-终点", "", "", "", executeStatePara.endStockArea.CN_S_STOCK_CODE, executeStatePara.endStockArea.CN_S_AREA_CODE, trans);
                        }

                        if (executeStatePara.transportTask.CN_C_START_IS_CONTROL_QTY.Equals("Y"))
                        {
                            //解绑托盘与货位的关系
                            CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new
                            {
                                executeStatePara.transportTask.CN_S_TRAY_CODE,
                                CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                            }, trans);
                            Log.Detail(logPara, "解绑任务的托盘和起点货位关联！");

                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_START_BIT, "正常", "空", "预出库锁定", trans);
                            Log.Detail(logPara, "更新预出库锁定的货位状态为正常、空，起点货位号：" + executeStatePara.transportTask.CN_S_START_BIT);

                            ////更新起点货位的任务号
                            //CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_TASK_NO = "" }, new { CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT });
                            //Log.Detail(logPara, "更新起点货位" + executeStatePara.transportTask.CN_S_START_BIT + "的绑定任务号为空！");

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_START_BIT, "预出库锁定", "正常", "状态回报上架完成-起点", "", "", "", executeStatePara.startStockArea.CN_S_STOCK_CODE, executeStatePara.startStockArea.CN_S_AREA_CODE, trans);
                        }
                    }
                }
                #endregion

                #region 空托出（下架）
                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("空托出"))
                {
                    Log.Detail(logPara, "开始执行空托出！");
                    Log.Detail(logPara, "startTrayLocation: " + JsonConvert.SerializeObject(executeStatePara.startTrayLocation));
                    if (executeStatePara.startTrayLocation != null)
                    {
                        //解绑托盘与货位的关系
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new
                        {
                            executeStatePara.transportTask.CN_S_TRAY_CODE,
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);
                        Log.Detail(logPara, "解绑任务的托盘和起点货位关联！");

                        ////删除托盘产品关联
                        //CreateDAL<TN_WM_B_TRAY_ITEM_RELDAL>().Delete(" CN_S_TRAY_CODE='" + executeStatePara.transportTask.CN_S_TRAY_CODE + "' ");
                        //Log.Detail(logPara, "删除当前任务的托盘物料关联！");

                        if (isControlStockQty)
                        {
                            #region 添加下架记录，降库存

                            CompleteTaskDownHistory(executeStatePara, logPara, trans);

                            //获取配置是否启用收货区
                            var strategyValue = BLLCreator.Create<DapperBaseBLL>().GetStrategy(executeStatePara.transportTask.CN_S_STOCK_CODE, StrategyKey.AreaQtyDeliverGood);

                            if (strategyValue.Equals(Constants.Y))
                            {
                                if (executeStatePara.transportTask.CN_S_START_CONTROL_INV.Equals("Y"))
                                {
                                    CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_START_AREA, logPara, trans);
                                }

                                //增加终点库区（收货区）库存
                                CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_END_AREA, logPara, trans);
                            }
                            else
                            {
                                if (executeStatePara.transportTask.CN_S_START_CONTROL_INV.Equals("Y"))
                                {
                                    CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_START_AREA, logPara, trans);
                                    if (!executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运"))
                                    {
                                        //降低仓库库存
                                        CreateDAL<TN_WM_B_STOCK_QTYDAL>().ReduceStockQty(addStockQty, trans);
                                        Log.Detail(logPara, "降低仓库量表完成！");
                                    }
                                }
                            }

                            #endregion
                        }

                        if (executeStatePara.startIsCurrentTask != null && executeStatePara.transportTask.CN_C_START_IS_CONTROL_QTY.Equals("Y"))
                        {
                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_START_BIT, "正常", "空", "预出库锁定", trans);
                            Log.Detail(logPara, "更新预出库锁定的货位状态为正常、空，起始货位号：" + executeStatePara.transportTask.CN_S_START_BIT);

                            ////更新起点货位的任务号
                            //CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_TASK_NO = "" }, new { CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT });
                            //Log.Detail(logPara, "更新起点货位" + executeStatePara.transportTask.CN_S_START_BIT + "的绑定任务号为空！");

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_START_BIT, "预出库锁定", "正常", "状态回报下架完成-起点", "", "", "", executeStatePara.startStockArea.CN_S_STOCK_CODE, executeStatePara.startStockArea.CN_S_AREA_CODE, trans);
                        }

                        if (executeStatePara.transportTask.CN_C_END_IS_CONTROL_QTY.Equals("Y"))
                        {
                            var trayLocation = new TN_WM_B_TRAY_LOCATIONEntity()
                            {
                                CN_GUID = Guid.NewGuid().ToString(),
                                CN_N_INDEX = 1,
                                CN_S_CREATOR = "",
                                CN_S_CREATOR_BY = "",
                                CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT,
                                CN_S_STOCK_AREA = executeStatePara.transportTask.CN_S_END_AREA,
                                CN_S_STOCK_CODE = executeStatePara.transportTask.CN_S_STOCK_CODE,
                                CN_S_TRAY_CODE = executeStatePara.transportTask.CN_S_TRAY_CODE,
                                CN_T_CREATE = DateTime.Now
                            };
                            ////添加托盘货位
                            //CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Add(trayLocation, trans);

                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_END_BIT, "正常", "空", "预入库锁定", trans);
                            Log.Detail(logPara, "更新预入库锁定的货位状态为正常、满，结束货位号：" + executeStatePara.transportTask.CN_S_END_BIT);

                            ////更新终点货位的任务号
                            //CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_TASK_NO = "" }, new { CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT });
                            //Log.Detail(logPara, "更新终点货位" + executeStatePara.transportTask.CN_S_END_BIT + "的绑定任务号为空！");

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_END_BIT, "预入库锁定", "正常", "状态回报下架完成-终点", "", "", "", executeStatePara.endStockArea.CN_S_STOCK_CODE, executeStatePara.endStockArea.CN_S_AREA_CODE, trans);
                        }
                    }
                }
                #endregion

                #region 移库

                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("移库"))
                {
                    var trayLocation = new TN_WM_B_TRAY_LOCATIONEntity()
                    {
                        CN_GUID = Guid.NewGuid().ToString(),
                        CN_N_INDEX = 1,
                        CN_S_CREATOR = "",
                        CN_S_CREATOR_BY = "",
                        CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT,
                        CN_S_STOCK_AREA = executeStatePara.transportTask.CN_S_END_AREA,
                        CN_S_STOCK_CODE = executeStatePara.transportTask.CN_S_STOCK_CODE,
                        CN_S_TRAY_CODE = executeStatePara.transportTask.CN_S_TRAY_CODE,
                        CN_T_CREATE = DateTime.Now
                    };

                    if (executeStatePara.startTrayLocation != null)
                    {
                        //解绑托盘与货位的关系
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Delete(new
                        {
                            executeStatePara.transportTask.CN_S_TRAY_CODE,
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);
                        Log.Detail(logPara, "解绑任务的托盘和起点货位关联！");
                    }

                    if (executeStatePara.endTrayLocation == null)
                    {
                        //添加托盘货位
                        CreateDAL<DapperDAL<TN_WM_B_TRAY_LOCATIONEntity>>().Add(trayLocation, trans);
                        Log.Detail(logPara, "添加托盘货位关联，内容：" + LogDescribe.Content(trayLocation));

                        if (isControlStockQty)
                        {
                            #region 下架记录
                            CompleteTaskDownHistory(executeStatePara, logPara, trans);
                            #endregion

                            #region 上架记录

                            CompleteTaskUpHistory(executeStatePara, logPara, trans);

                            if (string.IsNullOrEmpty(executeStatePara.transportTask.CN_S_END_CONTROL_INV))
                            {
                                Log.Detail(logPara, "终点库区" + executeStatePara.transportTask.CN_S_END_AREA + "不管控库存！executeStatePara.transportTask.CN_S_END_CONTROL_INV：" + executeStatePara.transportTask.CN_S_END_CONTROL_INV);
                                trans.Rollback();
                                return;
                            }

                            #endregion

                            #region 库存
                            if (executeStatePara.transportTask.CN_S_START_CONTROL_INV.Equals("Y"))  //降低起点库存
                            {
                                CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaQtyAndAllocQty(addAreaQty, executeStatePara.transportTask.CN_S_START_AREA, logPara, trans);
                            }

                            if (executeStatePara.transportTask.CN_S_END_CONTROL_INV.Equals("Y"))   //增加终点库存
                            {
                                //按未入库量增加结束库区量
                                CreateDAL<TN_WM_B_AREA_QTYDAL>().AddAreaQty(addAreaQty, executeStatePara.transportTask.CN_S_END_AREA, logPara, trans);
                            }
                            #endregion
                        }

                        //终点
                        if (executeStatePara.endIsCurrentTask != null && executeStatePara.transportTask.CN_C_END_IS_CONTROL_QTY.Equals("Y"))
                        {
                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_END_BIT, "正常", "满", "预入库锁定", trans);
                            Log.Detail(logPara, "更新预入库锁定的货位状态为正常、满，货位号：" + executeStatePara.transportTask.CN_S_END_BIT);

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_END_BIT, "预入库锁定", "正常", "状态回报入库完成-终点", "", "", "", executeStatePara.endStockArea.CN_S_STOCK_CODE, executeStatePara.endStockArea.CN_S_AREA_CODE, trans);
                        }

                        //起点
                        if (executeStatePara.transportTask.CN_C_START_IS_CONTROL_QTY.Equals("Y"))
                        {
                            CreateDAL<TN_WM_TASKDAL>().UpdateState(executeStatePara.transportTask.CN_S_START_BIT, "正常", "空", "预出库锁定", trans);
                            Log.Detail(logPara, "更新预出库锁定的货位状态为正常、空，起点货位号：" + executeStatePara.transportTask.CN_S_START_BIT);

                            //货位状态变化
                            BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_START_BIT, "预出库锁定", "正常", "状态回报转运完成-起点", "", "", "", executeStatePara.startStockArea.CN_S_STOCK_CODE, executeStatePara.startStockArea.CN_S_AREA_CODE, trans);
                        }
                    }
                }

                #endregion

            });
            if (!transResult.Success) return transResult;
            return UpdateErpState(executeStatePara, logPara);
        }

        public override OperateResult CancelTask(ExecuteStateParaDto executeStatePara, LogPara logPara)
        {
            if (!executeStatePara.transportTask.CN_S_STATE.Equals("未执行") && !executeStatePara.transportTask.CN_S_STATE.Equals("执行中"))
            {
                return OperateResult.Error("只能取消未执行和执行中的任务！");
            }

            var result = UseTransaction(trans =>
            {
                //更新任务状态
                CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                {
                    CN_S_MODIFY = "",
                    CN_S_MODIFY_BY = "",
                    CN_T_END = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_STATE = executeStatePara.taskState
                }, new { executeStatePara.transportTask.CN_S_TASK_NO }, trans);
                Log.Detail(logPara, "更新任务状态为：" + executeStatePara.taskState);

                //终点
                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("入库") || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("移库")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("上架")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("下架")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("叫料")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("空托入")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("空托出"))
                {
                    if (executeStatePara.endIsCurrentTask != null && executeStatePara.transportTask.CN_C_END_IS_CONTROL_QTY.Equals("Y"))
                    {
                        CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationStateByCodeAndState(executeStatePara.transportTask.CN_S_END_BIT, "正常", "预入库锁定", null);

                        //更新终点货位的任务号
                        CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_TASK_NO = "" }, new { CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT });
                        Log.Detail(logPara, "更新终点货位" + executeStatePara.transportTask.CN_S_END_BIT + "的绑定任务号为空！");

                        //货位状态变化
                        BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_END_BIT, "预入库锁定", "正常", "状态回报入库取消", "", "", "", executeStatePara.endStockArea.CN_S_STOCK_CODE, executeStatePara.endStockArea.CN_S_AREA_CODE, null);
                    }
                }

                //起点
                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("入库") 
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("出库") 
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("转运")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("移库")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("上架")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("下架")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("叫料")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("空托入")
                    || executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("空托出"))
                {
                    if (executeStatePara.startIsCurrentTask != null && executeStatePara.transportTask.CN_C_START_IS_CONTROL_QTY.Equals("Y"))
                    {
                        CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateLocationStateByCodeAndState(executeStatePara.transportTask.CN_S_START_BIT, "正常", "预出库锁定", null);

                        //更新起点货位的任务号
                        CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_TASK_NO = "" }, new { CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT });
                        Log.Detail(logPara, "更新起点货位" + executeStatePara.transportTask.CN_S_START_BIT + "的绑定任务号为空！");

                        //货位状态变化
                        BLLCreator.Create<TN_WM_B_LOCATION_CHANGEBLL>().AddStateChange(executeStatePara.transportTask.CN_S_START_BIT, "预出库锁定", "正常", "状态回报" + executeStatePara.transportTask.CN_S_TASK_TYPE + "取消", "", "", "", executeStatePara.startStockArea.CN_S_STOCK_CODE, executeStatePara.startStockArea.CN_S_AREA_CODE, null);

                        if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("移库"))
                        {
                            //降库区分配量
                            CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAllocQty(executeStatePara.transportTask.CN_S_START_AREA, executeStatePara.transportTask.CN_S_TRAY_CODE, null, logPara);
                        }

                        if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("叫料"))
                        {
                            //降仓库分配量
                            CreateDAL<TN_WM_B_AREA_QTYDAL>().ReduceAreaAndStockAllocQty(executeStatePara.transportTask.CN_S_START_AREA, executeStatePara.transportTask.CN_S_TRAY_CODE, null, logPara);
                        }
                    }
                }

                if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("移库"))
                {
                    Log.Detail(logPara, "降移库任务" + executeStatePara.transportTask.CN_S_TASK_NO + "的移动量");
                    //降移库任务的移动量
                    var moveStockTaskDtl = CreateDAL<MoveStockTaskDAL>().GetDtlByTaskNo(executeStatePara.transportTask.CN_S_TASK_NO);
                    if (moveStockTaskDtl != null)
                    {
                        CreateDAL<MoveStockTaskDAL>().ReduceAllocQty(moveStockTaskDtl.CN_PARENT_GUID, trans);
                        //ReduceMoveQty(moveStockTaskDtl.CN_PARENT_GUID, moveStockTaskDtl.CN_F_QUANTITY.ToString(), trans);

                        //删除移库子表任务记录
                        CreateDAL<MoveStockTaskDAL>().DeleteDtl(" CN_S_TASK_NO='" + executeStatePara.transportTask.CN_S_TASK_NO + "' ", trans);
                    }
                    else
                    {
                        Log.Detail(logPara, "未找到移库任务" + executeStatePara.transportTask.CN_S_TASK_NO + "子表的数据");
                    }
                }
            });
            if (result.Success)
            {
                DeleteErpState(executeStatePara, logPara);
            }
            return result;
            
        }

        private OperateResult UpdateErpState(ExecuteStateParaDto executeStatePara, LogPara logPara)
        {
            var result = OperateResult.Succeed();

            if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("入库"))
            {
                var itemPound = BLLCreator.Create<TN_ER_ITEM_POUNDBLL>().Get(executeStatePara.transportTask.CN_S_TASK_NO);
                if (itemPound != null)
                {
                    result = BLLCreator.Create<TN_ER_ITEM_POUNDBLL>().Update(executeStatePara.transportTask.CN_S_TASK_NO, 0, logPara);
                }
            }

            if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("出库"))
            {
                var stockOutDtl = BLLCreator.Create<TN_ER_MATERIAL_STOCKOUT_DTLBLL>().Get(executeStatePara.transportTask.CN_S_TASK_NO);
                if (stockOutDtl != null)
                {
                    result = BLLCreator.Create<TN_ER_MATERIAL_STOCKOUT_DTLBLL>().Update(executeStatePara.transportTask.CN_S_TASK_NO, 0, logPara);
                }
            }
            return result;
        }

        private OperateResult DeleteErpState(ExecuteStateParaDto executeStatePara, LogPara logPara)
        {
            var result = OperateResult.Succeed();

            if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("入库"))
            {
                var itemPound = BLLCreator.Create<TN_ER_ITEM_POUNDBLL>().Get(executeStatePara.transportTask.CN_S_TASK_NO);
                if (itemPound != null)
                {
                    result = BLLCreator.Create<TN_ER_ITEM_POUNDBLL>().Delete(executeStatePara.transportTask.CN_S_TASK_NO, logPara);
                }
            }

            if (executeStatePara.transportTask.CN_S_TASK_TYPE.Equals("出库"))
            {
                var stockOutDtl = BLLCreator.Create<TN_ER_MATERIAL_STOCKOUT_DTLBLL>().Get(executeStatePara.transportTask.CN_S_TASK_NO);
                if (stockOutDtl != null)
                {
                    result = BLLCreator.Create<TN_ER_MATERIAL_STOCKOUT_DTLBLL>().Delete(executeStatePara.transportTask.CN_S_TASK_NO, logPara);
                }
            }
            return result;
        }

        #endregion

        #region 称重

        public CommResponse InCarPound(string carNo, string areaCode, string weight, string itemType, string supplierCode, LogPara logPara)
        {
            var curWeight = Convert.ToDecimal(weight);
            if (curWeight <= 0)
                return CommResponse.Error("重量不能为空！", ErrorEnum.VerifyError);

            //验证车牌号是否存在 微信端已经登记
            //var carInfo = BLLCreator.Create<MiddleLibraryBLL>().GetCarInfo(carNo);
            //if (carInfo == null) return CommResponse.Error("未找到当前车牌信息，是否中间库中未同步车辆信息！", ErrorEnum.VerifyError);

            //库区是否存在
            var areaModel = DALCreator.Create<TN_WMS_AREADAL>().GetModel(areaCode);
            if (areaModel == null)
                return CommResponse.Error("未找到当前库区！");

            //更新当前车的磅单号为完成
            BLLCreator.Create<TN_ER_CAR_POUNDBLL>().UpdateState(areaCode, "已完成", logPara);

            //生产磅单号
            var postData = "{\"appCode\":\"" + Constants.appCode + "\",\"ruleName\":\"" + Constants.Rule_CarPound + "\",\"orgId\":\"0\",\"orgFlag\":\"\"}";
            var carPoundNo = WebApiManager.HttpAutoBom_Post("api/BillRule/GenBillNo", postData);
            if (string.IsNullOrEmpty(carPoundNo))
                return CommResponse.Error("获取AutoBom磅单号异常，检查是否配置“大磅单号”的编码规则！");

            var carPound = new TN_ER_CAR_POUNDEntity
            {
                CN_GUID = Guid.NewGuid().ToString(),
                CN_S_CAR_NO = carNo,
                CN_S_UNLOCAD_AREA_CODE = areaCode,
                CN_F_WEIGHT = curWeight,
                CN_S_ITEM_TYPE = itemType,
                CN_S_POUND_NO = carPoundNo,
                CN_T_ARRIVE = DateTime.Now,
                CN_T_CREATE = DateTime.Now,
                CN_S_VENDOR_NO = supplierCode,
                CN_S_STOCK_CODE = "NTCK",
                CN_S_STATE = "执行中",
                CN_T_OUT = DateTime.Now,
                CN_N_SYNC = 2//0 2状态为初始化磅单，离厂后状态更新为0才允许更新到中间库
            };

            //保存
            var result = BLLCreator.Create<TN_ER_CAR_POUNDBLL>().Add(carPound);
            if (!result.Success) return CommResponse.Error(result.Msg);
            return CommResponse.Normal();
        }

        public CommResponse OutCarPound(string carNo, string weight, LogPara logPara)
        {
            //验证车牌号是否存在
            var carInfo = BLLCreator.Create<MiddleLibraryBLL>().GetCarInfo(carNo);
            if (carInfo == null) return CommResponse.Error("未找到当前车牌信息，是否中间库中未同步车辆信息！", ErrorEnum.VerifyError);

            var carPound = BLLCreator.Create<TN_ER_CAR_POUNDBLL>().GetByCarNo(carNo, " ORDER BY CN_T_CREATE DESC ");
            if (carPound == null)
                return CommResponse.Error("未找到当前车号的磅单！", ErrorEnum.VerifyError);

            carPound.CN_F_CAR_WEIGHT = Convert.ToDecimal(weight);
            if (carPound.CN_F_CAR_WEIGHT <= 0)
                return CommResponse.Error("重量必须大于0！", ErrorEnum.VerifyError);

            carPound.CN_F_GROSS_WEIGHT = carPound.CN_F_WEIGHT - carPound.CN_F_CAR_WEIGHT;
            carPound.CN_T_OUT = DateTime.Now;
            carPound.CN_N_SYNC = 0;
            var result = BLLCreator.Create<TN_ER_CAR_POUNDBLL>().Update(carPound, new { carPound.CN_GUID }, logPara);
            if (!result.Success) return CommResponse.Error(result.Msg);
            return CommResponse.Normal();
        }

        #endregion
        
    }
}