增加ChageWay接口

zhao

2021-07-09 0821715ebc11d3934d0594a1cc2c39686d808906

增加ChageWay接口

 HH.WMS.BLL/Pda/ZCBLL.cs

@@ -782,35 +782,6 @@
            Log.Info("处理位置信息位置三：", JsonConvert.SerializeObject(entity));
        }

        private OperateResult TransportSuccess(TN_WM_SERVICE_EXECEntity _serviceExec)
        {
            return UseTransaction(trans =>
            {
                if (_serviceExec.Update)
                {
                    var or = BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().Update(new
                    {
                        CN_S_START_LOCATION = _serviceExec.CN_S_START_LOCATION,
                        CN_S_END_LOCATION = _serviceExec.CN_S_END_LOCATION,
                        CN_C_COMPLETE = _serviceExec.CN_C_COMPLETE,
                        CN_C_SEND_MES = _serviceExec.CN_C_SEND_MES,
                        CN_S_MSG = _serviceExec.CN_S_MSG
                    }, new
                    {
                        CN_S_TASK_NO = _serviceExec.CN_S_TASK_NO
                    });
                    if (!or.Success)
                        throw new Exception(or.Msg);
                }
                else
                {
                    var or = BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().Add(_serviceExec);
                    if (!or.Success)
                        throw new Exception(or.Msg);
                }
            });
        }

        #region 服务执行记录日志分页
        /// <summary>
        /// 服务执行记录日志分页
@@ -1198,1648 +1169,6 @@
                Log.DomainInfo("SelfManageTask Error", ex.Message);
            }
        }

        #region 货位状态

        // 接驳位锁定状态：预入库锁定、预出库锁定
        // 接驳位空闲状态：正常
        // 准备点状态同接驳位
        // 立库锁定状态：  预入库锁定、预出库锁定
        // 立库空闲状态：  空(入库前)、满(出库前)

        // 创建任务前、执行任务前      检查货位状态
        // 完成任务后                  清除货位状态
        // 执行失败后                  如何处理?

        #endregion

        #region 半成品

        #region 空托出库

        /// <summary>
        /// 创建空托出库并行子任务
        /// </summary>
        public OperateResult ExecBCP_KTCK_Add(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                // 空托出库和满托入库是反向的
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                // 准备点
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                // 立库->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_END_AREA,
                    CN_S_START_BIT = task.CN_S_END_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.BCP_KTCK_SUB_1,
                    CN_S_EXT3 = ""
                };
                // 准备点->线边
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = readyBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = readyBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_START_AREA,
                    CN_S_END_BIT = task.CN_S_START_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.BCP_KTCK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建半成品-空托出库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 创建半成品-空托出库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中 记录接驳位
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing,
                        CN_S_CONNECT_BIT = bit.bit
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建半成品-空托出库子任务失败，主任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 执行空托出库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecBCP_KTCK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 立库 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = task1.CN_S_START_BIT }, trans);
                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务1状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task1);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行半成品-空托出库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行空托出库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecBCP_KTCK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位的准备点货位
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 准备点 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.readybit }, trans);
                    // 线边货位不管控

                    // 子任务2状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task2);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行半成品-空托出库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #region 满托入库

        /// <summary>
        /// 创建 半成品-满托入库 子任务一
        /// </summary>
        public OperateResult ExecBCP_MTRK_AddSub1(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 线边->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_3",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.BCP_MTRK_SUB_1,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建半成品-满托入库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建半成品-满托入库子任务一失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 创建 半成品-满托入库 子任务二
        /// </summary>
        public OperateResult ExecBCP_MTRK_AddSub2(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 接驳位->立库
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_4",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.BCP_MTRK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建满托入库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建半成品-满托入库子任务二失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }

        /// <summary>
        /// 执行半成品-满托入库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecBCP_MTRK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 线边货位不管控

                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务一状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task1);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行半成品-满托入库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行半成品-满托入库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecBCP_MTRK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 接驳位 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 立库预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = task2.CN_S_END_BIT }, trans);

                    // 子任务二状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task2);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行半成品-满托入库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #endregion

        #region 成型机

        #region 半成品回库

        /// <summary>
        /// 创建 成型机-半成品回库 子任务一
        /// </summary>
        public OperateResult ExecCXJ_BCPHK_AddSub1(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 线边->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_BCPHK_SUB_1,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机-半成品回库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机-半成品回库子任务一失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 创建 成型机-半成品回库 子任务二
        /// </summary>
        public OperateResult ExecCXJ_BCPHK_AddSub2(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 接驳位->立库
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_BCPHK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机-半成品回库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机-半成品回库子任务二失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }

        /// <summary>
        /// 执行成型机-半成品回库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_BCPHK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 线边货位不管控

                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务一状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task1);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-半成品回库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行成型机-半成品回库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_BCPHK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 接驳位 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 立库预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = task2.CN_S_END_BIT }, trans);

                    // 子任务二状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task2);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-半成品回库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #region 满托出库

        /// <summary>
        /// 创建满托出库并行子任务
        /// </summary>
        public OperateResult ExecCXJ_MTCK_Add(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                // 准备点
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                // 立库->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_MTCK_SUB_1,
                    CN_S_EXT3 = ""
                };
                // 准备点->线边
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = readyBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = readyBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_MTCK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机-满托出库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 创建成型机-满托出库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中 记录接驳位
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing,
                        CN_S_CONNECT_BIT = bit.bit
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机-满托出库子任务失败，主任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 执行满托出库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_MTCK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 立库 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = task1.CN_S_START_BIT }, trans);
                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务1状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task1);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-满托出库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行满托出库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_MTCK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位的准备点货位
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 准备点 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.readybit }, trans);
                    // 线边货位不管控

                    // 子任务2状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task2);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-满托出库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #region 回托回库-空托入库

        /// <summary>
        /// 创建 成型机-空托回库-空托入库 子任务一
        /// </summary>
        public OperateResult ExecCXJ_KTHK_KTRK_AddSub1(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 线边->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_KTHK_KTRK_SUB_1,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机-空托回库-空托入库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机-空托回库-空托入库子任务一失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 创建 成型机-空托回库-空托入库 子任务二
        /// </summary>
        public OperateResult ExecCXJ_KTHK_KTRK_AddSub2(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 接驳位->立库
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.CXJ_KTHK_KTRK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机-空托回库-空托入库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机-空托回库-空托入库子任务二失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }

        /// <summary>
        /// 执行成型机-空托回库-空托入库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_KTHK_KTRK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 线边货位不管控

                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务一状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task1);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-空托回库-空托入库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行成型机-空托回库-空托入库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecCXJ_KTHK_KTRK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 接驳位 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 立库预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = task2.CN_S_END_BIT }, trans);

                    // 子任务二状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task2);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机-空托回库-空托入库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #endregion

        #region 带束

        #region 半成品及空托回库

        /// <summary>
        /// 创建 成型机带束-半成品/空托回库 子任务一
        /// </summary>
        public OperateResult ExecDS_BCPKTHK_AddSub1(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 线边->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.DS_BCPKTHK_SUB_1,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机带束-半成品/空托回库-子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机带束-半成品/空托回库子任务一失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 创建 成型机带束-半成品/空托回库 子任务二
        /// </summary>
        public OperateResult ExecDS_BCPKTHK_AddSub2(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                // 接驳位->立库
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.DS_BCPKTHK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机带束-半成品/空托回库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机带束-半成品/空托回库子任务二失败，任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }

        /// <summary>
        /// 执行成型机带束-半成品/空托回库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecDS_BCPKTHK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 线边货位不管控

                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务一状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task1);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机带束-半成品/空托回库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行成型机带束-半成品/空托回库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecDS_BCPKTHK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });

                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 接驳位 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 立库预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = task2.CN_S_END_BIT }, trans);

                    // 子任务二状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task2);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机带束-半成品/空托回库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #region 满托出库

        /// <summary>
        /// 创建满托出库并行子任务
        /// </summary>
        public OperateResult ExecDS_MTCK_Add(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            OperateResult re = OperateResult.Error("未知错误");

            try
            {
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                // 准备点
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                // 立库->接驳位
                TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_1",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = task.CN_S_START_AREA,
                    CN_S_START_BIT = task.CN_S_START_BIT,
                    CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                    CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.DS_MTCK_SUB_1,
                    CN_S_EXT3 = ""
                };
                // 准备点->线边
                TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                {
                    CN_S_TASK_NO = task.CN_S_TASK_NO + "_2",
                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_BF_TASK_NO = "",
                    CN_S_AF_TASK_NO = "",
                    CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                    CN_S_START_AREA = readyBit.CN_S_AREA_CODE,
                    CN_S_START_BIT = readyBit.CN_S_LOCATION_CODE,
                    CN_S_END_AREA = task.CN_S_END_AREA,
                    CN_S_END_BIT = task.CN_S_END_BIT,
                    CN_N_PRIORITY = 1,
                    CN_S_CREATOR = "sys",
                    CN_S_CREATOR_BY = "sys",
                    CN_T_CREATE = DateTime.Now,
                    CN_T_MODIFY = DateTime.Now,
                    CN_S_REMARK = "",
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_EXT1 = task.CN_S_TASK_NO,
                    CN_S_EXT2 = TaskFlagConstants.DS_MTCK_SUB_2,
                    CN_S_EXT3 = ""
                };

                UseTransaction(trans =>
                {
                    // 创建成型机带束-满托出库子任务一
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 创建成型机带束-满托出库子任务二
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

                    // 主任务状态置为执行中 记录接驳位
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing,
                        CN_S_CONNECT_BIT = bit.bit
                    }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("创建成型机带束-满托出库子任务失败，主任务编号=" + task.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }

            return re;
        }
        /// <summary>
        /// 执行满托出库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecDS_MTCK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位
                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.bit
                });
                if (connectBit == null)
                    throw new Exception("未找到接驳位货位：" + bit.bit);
                if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 立库 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = task1.CN_S_START_BIT }, trans);
                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = bit.bit }, trans);
                    // 子任务1状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task1));
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task1);
                    Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机带束-满托出库子任务一失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行满托出库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecDS_MTCK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto bit)
        {
            OperateResult or = OperateResult.Error("未知错误");

            try
            {
                // 执行前检查货位状态
                // 接驳位的准备点货位
                var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                {
                    CN_S_LOCATION_CODE = bit.readybit
                });
                if (readyBit == null)
                    throw new Exception("未找到准备点货位：" + bit.readybit);
                if (readyBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                    throw new Exception("准备点货位：" + bit.readybit + "存在未执行完的任务");

                UseTransaction(trans =>
                {
                    // 准备点 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = bit.readybit }, trans);
                    // 线边货位不管控

                    // 子任务2状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(task2));
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task2);
                    Log.Detail(LogType.LogPara("调用AMS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(or));
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行成型机带束-满托出库子任务二失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #endregion
    }

    /// <summary>
@@ -2871,37 +1200,6 @@
        /// 空托入库
        /// </summary>
        public static string KTRK = "空托入库";
    }

    /// <summary>
    /// 接口同步的业务类型定义
    /// </summary>
    public class BusinessTypeConstants
    {
        /// <summary>
        /// 半成品满托入库
        /// </summary>
        public static string BCP_MTRK = "1";
        /// <summary>
        /// 成型机半成品回库
        /// </summary>
        public static string CXJ_BCPHK = "2";
        /// <summary>
        /// 成型机空桶回库
        /// </summary>
        public static string CXJ_KTHK = "3";
        /// <summary>
        /// 成型机满托出库
        /// </summary>
        public static string CXJ_MTCK = "4";
        /// <summary>
        /// 成型机带束回库
        /// </summary>
        public static string CXJ_DSHK = "5";
        /// <summary>
        /// 成型机带束满托出库
        /// </summary>
        public static string CXJ_DSMTCK = "6";
    }

    /// <summary>
@@ -2959,92 +1257,6 @@
        /// 带束-满托出库
        /// </summary>
        public static string DS_MTCK = "成型机带束-满托出库";

        #endregion
    }

    /// <summary>
    /// 任务标识常量
    /// </summary>
    public class TaskFlagConstants
    {
        /// <summary>
        /// 主任务
        /// </summary>
        public static string ROOT = "主任务";

        #region 半成品

        /// <summary>
        /// 半成品-空托出库子任务一
        /// </summary>
        public static string BCP_KTCK_SUB_1 = "半成品-空托出库-子任务一";
        /// <summary>
        /// 半成品-空托出库子任务二
        /// </summary>
        public static string BCP_KTCK_SUB_2 = "半成品-空托出库-子任务二";
        /// <summary>
        /// 半成品-满托入库子任务一
        /// </summary>
        public static string BCP_MTRK_SUB_1 = "半成品-满托入库-子任务一";
        /// <summary>
        /// 半成品-满托入库子任务二
        /// </summary>
        public static string BCP_MTRK_SUB_2 = "半成品-满托入库-子任务二";

        #endregion

        #region 成型机

        /// <summary>
        /// 成型机-半成品回库-子任务一
        /// </summary>
        public static string CXJ_BCPHK_SUB_1 = "成型机-半成品回库-子任务一";
        /// <summary>
        /// 成型机-半成品回库-子任务二
        /// </summary>
        public static string CXJ_BCPHK_SUB_2 = "成型机-半成品回库-子任务一";
        /// <summary>
        /// 成型机-空托回库-记录任务
        /// </summary>
        public static string CXJ_KTHK_RECORD = "成型机-空托回库-记录任务";
        /// <summary>
        /// 成型机-空托回库-入库阶段-子任务一
        /// </summary>
        public static string CXJ_KTHK_KTRK_SUB_1 = "成型机-空托回库-入库阶段-子任务一";
        /// <summary>
        /// 成型机-空托回库-入库阶段-子任务二
        /// </summary>
        public static string CXJ_KTHK_KTRK_SUB_2 = "成型机-空托回库-入库阶段-子任务二";
        /// <summary>
        /// 成型机-满托出库-子任务一
        /// </summary>
        public static string CXJ_MTCK_SUB_1 = "成型机-满托出库-子任务一";
        /// <summary>
        /// 成型机-满托出库-子任务二
        /// </summary>
        public static string CXJ_MTCK_SUB_2 = "成型机-满托出库-子任务二";

        #endregion

        #region 带束

        /// <summary>
        /// 成型机带束-半成品/空托回库-子任务一
        /// </summary>
        public static string DS_BCPKTHK_SUB_1 = "成型机带束-半成品/空托回库-子任务一";
        /// <summary>
        /// 成型机带束-半成品/空托回库-子任务二
        /// </summary>
        public static string DS_BCPKTHK_SUB_2 = "成型机带束-半成品/空托回库-子任务二";
        /// <summary>
        /// 成型机带束-满托出库-子任务一
        /// </summary>
        public static string DS_MTCK_SUB_1 = "成型机带束-满托出库-子任务一";
        /// <summary>
        /// 成型机带束-满托出库-子任务二
        /// </summary>
        public static string DS_MTCK_SUB_2 = "成型机带束-满托出库-子任务二";

        #endregion
    }

 HH.WMS.BLL/SysMgr/TN_WM_TASKBLL.cs

@@ -175,6 +175,48 @@
            });
        }

        public OperateResult ChangeWay(TN_WM_TASKEntity task, AutoBomLocationEntity locationModel, AutoBomStockAreaEntity locationArea, string type)
        {
            var oldLocationCode = type.Equals("start") ? task.CN_S_START_BIT : task.CN_S_END_BIT;
            return UseTransaction(trans =>
            {
                //锁定改道后的货位使用状态和锁定状态
                if (locationArea.CN_C_IS_CONTROL_QTY.Equals("Y"))
                    CreateDAL<TN_WM_LOCATION_EXTDAL>().UpdateStateAndTaskNo(task.CN_S_TASK_NO, locationModel.CN_S_LOCATION_CODE, Constants.Location_State_OutLock, "", null, "");
                if (type.Equals("start"))
                {
                    //修改任务库区和货位
                    CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                    {
                        CN_S_START_BIT = locationModel.CN_S_LOCATION_CODE,
                        CN_S_START_AREA = locationModel.CN_S_AREA_CODE,
                        CN_C_START_IS_CONTROL_QTY = locationArea.CN_C_IS_CONTROL_QTY,
                        CN_S_START_CONTROL_INV = locationArea.CN_C_IS_INVENTORY,
                        CN_S_TASK_TYPE = "改道"
                    },
                        new { CN_S_TASK_NO = task.CN_S_TASK_NO });
                }
                else
                {
                    CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                    {
                        CN_S_END_BIT = locationModel.CN_S_LOCATION_CODE,
                        CN_S_END_AREA = locationModel.CN_S_AREA_CODE,
                        CN_C_END_IS_CONTROL_QTY = locationArea.CN_C_IS_CONTROL_QTY,
                        CN_S_END_CONTROL_INV = locationArea.CN_C_IS_INVENTORY,
                        CN_S_TASK_TYPE = "改道"
                    },
                        new { CN_S_TASK_NO = task.CN_S_TASK_NO });
                }
                //将原来的货位置为正常
                CreateDAL<DapperDAL<TN_WM_LOCATION_EXTEntity>>().Update(new { CN_S_LOCATION_STATE = Constants.Location_State_Normal }, new { CN_S_LOCATION_CODE = oldLocationCode }, trans);

                Log.Info("改道", "ChangeWay接口，更改任务起点，任务号：" + task.CN_S_TASK_NO + "，起点更改为：" + locationModel.CN_S_LOCATION_CODE
                + "，起点状态更改为：" + Constants.Location_State_OutLock
                + "，原起点" + oldLocationCode + "的状态更改为：" + Constants.Location_State_Normal);
            });
        }

        #endregion

        #region DELETE

 HH.WMS.Entitys/External/ChangeWayResult.cs

New file
@@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HH.WMS.Entitys.External
{
    public class ChangeWayResult
    {
        public bool success { get; set; }
        public string errCode { get; set; }
        public string errMsg { get; set; }
        public string location { get; set; }
    }
}

 HH.WMS.Entitys/HH.WMS.Entitys.csproj

@@ -68,6 +68,7 @@
    <Compile Include="Algorithm\TN_AB_STOCKEntity.cs" />
    <Compile Include="Dto\ZCTransferDto.cs" />
    <Compile Include="Entitys\Mes\TN_MES_TASK.cs" />
    <Compile Include="External\ChangeWayResult.cs" />
    <Compile Include="External\ZCReceiveTaskEntity.cs" />
    <Compile Include="Wcs\WcsResponse.cs" />
    <Compile Include="Ams\AmsAddTask.cs" />

 HH.WMS.WebApi/Controllers/WmsApiController.cs

@@ -374,6 +374,110 @@
        }
        #endregion

        #region 中策
        /// <summary>
        /// 改道
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        [HttpPost]
        public string ChangeWay(dynamic param)
        {
            var logPara = new TOOLS.LOG.LogPara("改道");
            logPara.Push("接口请求参数：" + JsonConvert.SerializeObject(param));

            var result = new ChangeWayResult() { success = false, errCode = "200", location = "" };
            try
            {
                //任务号
                string taskNo = param.taskNo;
                //改道类型（起点/终点）
                string updateType = param.updateType;
                //改道类型对应的原因
                string reasonCode = param.reasonCode;
                if (string.IsNullOrEmpty(taskNo))
                {
                    result.errMsg = "任务号不可为空";
                    result.errCode = "102";
                }
                if (string.IsNullOrEmpty(updateType) || !(updateType.Equals("起点") || updateType.Equals("终点")))
                {
                    result.errMsg += " 改道类型不正确";
                    result.errCode = "102";
                }
                if (taskNo.Split('_').Length <= 1)
                {
                    result.errMsg += " 主任务无法变更起点";
                    result.errCode = "102";
                }
                string preTaskNo = taskNo.Split('_')[0] + "_1";
                string navTaskNo = taskNo.Split('_')[1];
                if (navTaskNo != "2")
                {
                    result.errMsg += " 当前任务无前置任务，不支持变更起点";
                    result.errCode = "102";
                }
                var preTask = BLLCreator.Create<DapperBLL<TN_WM_TASKEntity>>().GetSingleEntity(new { CN_S_TASK_NO = preTaskNo });
                if (preTask == null)
                {
                    result.errMsg += "未找到此任务的主任务，任务号：" + taskNo;
                    result.errCode = "102";
                }
                var currentTask = BLLCreator.Create<DapperBLL<TN_WM_TASKEntity>>().GetSingleEntity(new { CN_S_TASK_NO = taskNo });
                if (currentTask == null)
                {
                    result.errMsg += "未找到此任务，任务号：" + taskNo;
                    result.errCode = "102";
                }
                // 主任务的立库接驳位
                string connectBit = preTask.CN_S_END_BIT;
                AutoBomLocationEntity locationModel = DALCreator.Create<TN_WMS_LOCATIONDAL>().GetModel(connectBit);
                var locationArea = DALCreator.Create<TN_AB_STOCK_LOCATIONDAL>().GetAreaModelByLocation(connectBit);
                if (locationModel == null)
                {
                    result.errMsg += "未找到接驳位货位：" + connectBit;
                    result.errCode = "102";
                }
                if (locationModel.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                {
                    result.errMsg += "接驳位货位：" + connectBit + "存在未执行完的任务";
                    result.errCode = "102";
                }

                if (result.errCode == "200")
                {
                    var sqlResult = BLLCreator.Create<TN_WM_TASKBLL>().ChangeWay(currentTask, locationModel, locationArea,"start");

                    if (!sqlResult.Success)
                        result.errMsg = sqlResult.Msg;
                    else
                    {
                        result.success = true;
                        result.errCode = "100";
                        result.location = connectBit;
                    }
                }

                if (result.success)
                {
                    logPara.PushAndAdd("改道成功！");
                }
                else
                {
                    logPara.PushAndAdd("改道失败，原因：" + result.errMsg);
                }
            }
            catch (Exception ex)
            {
                result.errCode = "200";
                result.errMsg = "ChangeWay方法异常" + ex.Message + ex.StackTrace;
                logPara.PushAndAdd(ex);
            }
            return JsonConvert.SerializeObject(result);
        }

        #endregion

        #region 宇寿 叫料
        /// <summary>
        /// 叫料