中策下任务接口

zhao

2021-07-07 2fdf959ac739edd6de84aa8053b8b9683dce8e8b

中策下任务接口

 HH.WMS.BLL/External/WmsApiBaseBLL.cs

@@ -1512,29 +1512,23 @@

            #endregion

            string tno = executeStatePara.transportTask.CN_S_TASK_NO;
            if (tno.IndexOf('_') > 0)
            {
                tno = tno.Substring(tno.IndexOf("_") + 1);
            }
            // 获取主任务
            var task = executeStatePara.transportTask;
            if (!string.IsNullOrEmpty(task.CN_S_EXT1))
            var task = BLLCreator.CreateDapper<TN_WM_TASKEntity>().GetSingleEntity(new
            {
                task = BLLCreator.CreateDapper<TN_WM_TASKEntity>().GetSingleEntity(new
                {
                    CN_S_TASK_NO = task.CN_S_EXT1
                CN_S_TASK_NO = tno
                });
            }
            TN_WM_TASKEntity task_kthk = null;
            // 特殊业务
            // 成型机满托出库完成时，要执行空托回库任务
            if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.CXJ_MTCK_SUB_2)
            Log.Detail(logPara, "获取主任务：任务编号： " + tno);
            // mes任务
            var mes_task = BLLCreator.CreateDapper<TN_MES_TASK>().GetSingleEntity(new
            {
                // 查找终点货位(线边货位)是否有未执行的空托回库任务
                task_kthk = BLLCreator.CreateDapper<TN_WM_TASKEntity>().GetSingleEntity(new
                {
                    CN_S_START_AREA = executeStatePara.transportTask.CN_S_END_AREA,
                    CN_S_START_BIT = executeStatePara.transportTask.CN_S_END_BIT,
                    CN_S_STATE = Constants.TaskState_NoExecuted,
                    CN_S_EXT3 = TaskSectionConstants.CXJ_KTHK_RECORD
                task_no = task.CN_S_EXT1
                });
            }
            Log.Detail(logPara, "获取MES任务：任务编号： " + task.CN_S_EXT1);

            return UseTransaction(trans =>
            {
@@ -1549,453 +1543,60 @@
                }, new { executeStatePara.transportTask.CN_S_TASK_NO }, trans);
                Log.Detail(logPara, "更新任务状态-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO + "状态为：" + executeStatePara.taskState);

                //立库任务   子任务完成时，需要同步处理主任务   
                string taskNo = executeStatePara.transportTask.CN_S_TASK_NO;

                //立库任务   子任务完成时，需要同步处理主任务   
                if (taskNo.IndexOf('_') > 0)
                {
                    string fatherNo = taskNo.Substring(0, taskNo.IndexOf("_"));
                    string childNo = taskNo.Substring(taskNo.IndexOf("_") + 1);
                    string topNo = taskNo.Substring(0, taskNo.IndexOf("_"));
                    string navNo = taskNo.Substring(taskNo.IndexOf("_") + 1);

                    #region 海潮中策
                    //A到B的AGV搬运任务
                    if (navNo == "1")
                    {
                        if (mes_task.SECTION == TaskSectionConstants.BCP_KTCK ||
                            mes_task.SECTION == TaskSectionConstants.CXJ_MTCK ||
                            mes_task.SECTION == TaskSectionConstants.DS_MTCK)
                        {

                    #region 半成品

                    #region 空托出库

                    // 半成品-空托出库第一条子任务
                    if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.BCP_KTCK_SUB_1)
                    {
                        // 接驳位状态改为:满
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Full
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT
                        }, trans);
                        // 立库货位状态改为:空
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Empty
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);

                        Log.Detail(logPara, "半成品-空托出库子任务一完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + executeStatePara.transportTask.CN_S_END_BIT + "状态为：" + Constants.Location_State_Full
                            + "，更新立库状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Empty);
                    }
                    // 半成品-空托出库第二条子任务
                    else if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.BCP_KTCK_SUB_2)
                    {
                        // 主任务状态置为完成部分
                        // 主任务阶段置为半成品-满托入库
                        CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                        {
                            CN_T_END = DateTime.Now,
                            CN_T_MODIFY = DateTime.Now,
                            CN_S_STATE = Constants.TaskState_CompletePart,
                            CN_S_EXT3 = TaskSectionConstants.BCP_MTRK
                        }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                        // 接驳位状态改为:正常
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Normal
                        }, new
                        {
                            CN_S_LOCATION_CODE = task.CN_S_CONNECT_BIT
                        }, trans);
                        // 准备点货位状态改为:正常
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Normal
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);
                        // 线边货位不管控

                        Log.Detail(logPara, "半成品-空托出库子任务二完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + task.CN_S_CONNECT_BIT + "状态为：" + Constants.Location_State_Normal
                            + "，更新准备点状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Normal
                            + "，更新主任务-任务号：" + task.CN_S_TASK_NO + "状态为：" + Constants.TaskState_CompletePart + "-阶段为：" + TaskSectionConstants.BCP_MTRK);
                    }

                    #endregion

                    #region 满托入库

                    // 半成品-满托入库第一条子任务
                    else if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.BCP_MTRK_SUB_1)
                    {
                        // 主任务状态置为完成部分
                        // 主任务阶段置为半成品-满托入库-第二阶段
                        CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                        {
                            CN_T_END = DateTime.Now,
                            CN_T_MODIFY = DateTime.Now,
                            CN_S_STATE = Constants.TaskState_CompletePart,
                            CN_S_EXT3 = TaskSectionConstants.BCP_MTRK_SECOND
                        }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                        // 线边货位不管控

                        // 接驳位状态改为:满
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Full
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT
                        }, trans);

                        Log.Detail(logPara, "半成品-满托入库子任务一完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + executeStatePara.transportTask.CN_S_END_BIT + "状态为：" + Constants.Location_State_Full
                            + "，更新主任务-任务号：" + task.CN_S_TASK_NO + "状态为：" + Constants.TaskState_CompletePart + "-阶段为：" + TaskSectionConstants.BCP_MTRK_SECOND);
                    }
                    // 半成品-满托入库第二条子任务
                    else if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.BCP_MTRK_SUB_2)
                    {
                        // 主任务状态置为完成
                        // 阶段置为任务完成
                        CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                        {
                            CN_T_END = DateTime.Now,
                            CN_T_MODIFY = DateTime.Now,
                            CN_S_STATE = Constants.TaskState_Complete,
                            CN_S_EXT3 = TaskSectionConstants.COMPLETE
                        }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);

                        // 接驳位状态改为:正常
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Normal
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);
                        // 立库状态改为:满
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Full
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT
                        }, trans);

                        Log.Detail(logPara, "半成品-满托入库子任务二完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Normal
                            + "，更新立库状态-货位号：" + executeStatePara.transportTask.CN_S_END_BIT + "状态为：" + Constants.Location_State_Full
                            + "，更新主任务-任务号：" + task.CN_S_TASK_NO + "状态为：" + Constants.TaskState_Complete + "-阶段为：" + TaskSectionConstants.COMPLETE);
                    }

                    #endregion

                    #endregion

                    #region 成型机

                    #region 半成品回库

                    // 成型机-半成品回库第一条子任务
                    else if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_1)
                    {
                        // 主任务状态置为完成部分
                        // 主任务阶段置为成型机-半成品回库-第二阶段
                        CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                        {
                            CN_T_END = DateTime.Now,
                            CN_T_MODIFY = DateTime.Now,
                            CN_S_STATE = Constants.TaskState_CompletePart,
                            CN_S_EXT3 = TaskSectionConstants.CXJ_BCPHK_SECOND
                        }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                        // 线边货位不管控

                        // 接驳位状态改为:满
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Full
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT
                        }, trans);

                        Log.Detail(logPara, "成型机-半成品回库子任务一完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + executeStatePara.transportTask.CN_S_END_BIT + "状态为：" + Constants.Location_State_Full
                            + "，更新主任务-任务号：" + task.CN_S_TASK_NO + "状态为：" + Constants.TaskState_CompletePart + "-阶段为：" + TaskSectionConstants.CXJ_BCPHK_SECOND);
                    }
                    // 成型机-半成品回库第二条子任务
                    else if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_2)
                    {
                        // 主任务状态置为完成
                        // 主任务阶段置为任务完成
                        CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                        {
                            CN_T_END = DateTime.Now,
                            CN_T_MODIFY = DateTime.Now,
                            CN_S_STATE = Constants.TaskState_Complete,
                            CN_S_EXT3 = TaskSectionConstants.COMPLETE
                        }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);

                        // 接驳位状态改为:正常
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Normal
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);
                        // 立库状态改为:满
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Full
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT
                        }, trans);

                        Log.Detail(logPara, "成型机-半成品回库子任务二完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Normal
                            + "，更新立库状态-货位号：" + executeStatePara.transportTask.CN_S_END_BIT + "状态为：" + Constants.Location_State_Full
                            + "，更新主任务-任务号：" + task.CN_S_TASK_NO + "状态为：" + Constants.TaskState_Complete + "-阶段为：" + TaskSectionConstants.COMPLETE);
                    }

                    #endregion

                    #region 满托出库

                    // 成型机-满托出库第一条子任务
                    if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.CXJ_MTCK_SUB_1)
                    {
                        // 接驳位状态改为:满
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Full
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT
                        }, trans);
                        // 立库货位状态改为:空
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Empty
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);

                        Log.Detail(logPara, "成型机-满托出库子任务一完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + executeStatePara.transportTask.CN_S_END_BIT + "状态为：" + Constants.Location_State_Full
                            + "，更新立库状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Empty);
                    }
                    // 成型机-满托出库第二条子任务
                    else if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.CXJ_MTCK_SUB_2)
                    {
                        // 接驳位状态改为:正常
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Normal
                        }, new
                        {
                            CN_S_LOCATION_CODE = task.CN_S_CONNECT_BIT
                        }, trans);
                        // 准备点货位状态改为:正常
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Normal
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);
                        // 线边货位不管控

                        if (task_kthk == null)
                        {
                            // 没有需要执行的空托回库任务
                            // 主任务状态置为完成
                            // 主任务阶段置为完成
                            CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                            {
                                CN_S_STATE = Constants.TaskState_Complete,
                                CN_S_EXT3 = TaskSectionConstants.COMPLETE
                            }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);

                            Log.Detail(logPara, "成型机-满托出库子任务二完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + task.CN_S_CONNECT_BIT + "状态为：" + Constants.Location_State_Normal
                            + "，更新准备点状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Normal
                            + "，更新主任务-任务号：" + task.CN_S_TASK_NO + "状态为：" + Constants.TaskState_Complete + "-阶段为：" + TaskSectionConstants.COMPLETE
                            + "，未匹配到空托回库任务");
                        }
                        else
                        {
                            // 有需要执行的空托回库任务
                            // 主任务状态置为执行中（防止再次循环到）
                            // 主任务阶段置为成型机-空托入库
                            //主任务状态更改为:完成一半
                            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 = Constants.TaskState_Executing,
                                CN_S_EXT3 = TaskSectionConstants.CXJ_KTRK
                            }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                            // 空托回库任务阶段置为成型机-空托回库-入库阶段
                            // 空托回库任务主任务编号置为当前主任务
                                CN_S_STATE = Constants.TaskState_CompleteHalf
                            }, new { CN_S_TASK_NO = topNo }, trans);
                            Log.Detail(logPara, "更新主任务状态-任务号：" + topNo + "状态为：" + Constants.TaskState_CompleteHalf);
                        }
                    }

                    //B到C的立库搬运任务
                    if (navNo == "2")
                    {
                        //主任务状态更改为:完成
                            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_EXT3 = TaskSectionConstants.CXJ_KTHK_KTRK,
                                CN_S_EXT1 = task.CN_S_TASK_NO
                            }, new { CN_S_TASK_NO = task_kthk.CN_S_TASK_NO });
                            CN_S_STATE = Constants.TaskState_Complete
                        }, new { CN_S_TASK_NO = topNo }, trans);
                        Log.Detail(logPara, "更新主任务状态-任务号：" + topNo + "状态为：" + Constants.TaskState_Complete);

                            Log.Detail(logPara, "成型机-满托出库子任务二完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + task.CN_S_CONNECT_BIT + "状态为：" + Constants.Location_State_Normal
                            + "，更新准备点状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Normal
                            + "，更新主任务-任务号：" + task.CN_S_TASK_NO + "状态为：" + Constants.TaskState_Executing + "-阶段为：" + TaskSectionConstants.CXJ_KTRK
                            + "，匹配到空托回库任务-任务号：" + task_kthk.CN_S_TASK_NO + "阶段为：" + TaskSectionConstants.CXJ_KTHK_KTRK + "-关联主任务：" + task.CN_S_TASK_NO);
                        // mes任务进入下一阶段
                        CreateDAL<DapperDAL<TN_MES_TASK>>().Update(new
                        {
                            NeedTrig = Constants.Y
                        }, new { task_no = mes_task.task_no }, trans);
                        }
                    }

                    #endregion

                    #endregion

                    #region 成型机带束

                    #region 半成品/空托回库

                    // 成型机带束-半成品/空托回库第一条子任务
                    else if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.DS_BCPKTHK_SUB_1)
                    {
                        // 主任务状态置为完成部分
                        // 主任务阶段置为成型机带束-半成品/空托回库-第二阶段
                        CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                        {
                            CN_T_END = DateTime.Now,
                            CN_T_MODIFY = DateTime.Now,
                            CN_S_STATE = Constants.TaskState_CompletePart,
                            CN_S_EXT3 = TaskSectionConstants.DS_BCPKTHK_SECOND
                        }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                        // 线边货位不管控

                        // 接驳位状态改为:满
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Full
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT
                        }, trans);

                        Log.Detail(logPara, "成型机带束-半成品/空托回库子任务一完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + executeStatePara.transportTask.CN_S_END_BIT + "状态为：" + Constants.Location_State_Full
                            + "，更新主任务-任务号：" + task.CN_S_TASK_NO + "状态为：" + Constants.TaskState_CompletePart + "-阶段为：" + TaskSectionConstants.DS_BCPKTHK_SECOND);
                    }
                    // 成型机带束-半成品/空托回库第二条子任务
                    else if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.DS_BCPKTHK_SUB_2)
                    {
                        // 主任务状态置为完成
                        // 主任务阶段置为任务完成
                        CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                        {
                            CN_S_STATE = Constants.TaskState_Complete,
                            CN_S_EXT3 = TaskSectionConstants.COMPLETE
                        }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);

                        // 接驳位状态改为:正常
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Normal
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);
                        // 立库状态改为:满
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Full
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT
                        }, trans);

                        Log.Detail(logPara, "成型机带束-半成品/空托回库子任务二完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Normal
                            + "，更新立库状态-货位号：" + executeStatePara.transportTask.CN_S_END_BIT + "状态为：" + Constants.Location_State_Full
                            + "，更新主任务-任务号：" + task.CN_S_TASK_NO + "状态为：" + Constants.TaskState_Complete + "-阶段为：" + TaskSectionConstants.COMPLETE);
                    }

                    #endregion

                    #region 满托出库

                    // 成型机带束-满托出库第一条子任务
                    if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.DS_MTCK_SUB_1)
                    {
                        // 接驳位状态改为:满
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Full
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_END_BIT
                        }, trans);
                        // 立库货位状态改为:空
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Empty
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);

                        Log.Detail(logPara, "成型机带束-满托出库子任务一完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                            + "，更新接驳位状态-货位号：" + executeStatePara.transportTask.CN_S_END_BIT + "状态为：" + Constants.Location_State_Full
                            + "，更新立库状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Empty);
                    }
                    // 成型机带束-满托出库第二条子任务
                    else if (executeStatePara.transportTask.CN_S_EXT2 == TaskFlagConstants.DS_MTCK_SUB_2)
                    {
                        // 接驳位状态改为:正常
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Normal
                        }, new
                        {
                            CN_S_LOCATION_CODE = task.CN_S_CONNECT_BIT
                        }, trans);
                        // 准备点货位状态改为:正常
                        CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                        {
                            CN_S_LOCATION_STATE = Constants.Location_State_Normal
                        }, new
                        {
                            CN_S_LOCATION_CODE = executeStatePara.transportTask.CN_S_START_BIT
                        }, trans);
                        // 线边货位不管控

                        // 主任务状态置为完成
                        // 主任务阶段置为完成
                        CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                        {
                            CN_T_END = DateTime.Now,
                            CN_T_MODIFY = DateTime.Now,
                            CN_S_STATE = Constants.TaskState_Complete,
                            CN_S_EXT3 = TaskSectionConstants.COMPLETE
                        }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);

                        Log.Detail(logPara, "成型机带束-满托出库子任务二完成-任务号：" + executeStatePara.transportTask.CN_S_TASK_NO
                        + "，更新接驳位状态-货位号：" + task.CN_S_CONNECT_BIT + "状态为：" + Constants.Location_State_Normal
                        + "，更新准备点状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Normal
                        + "，更新主任务-任务号：" + task.CN_S_TASK_NO + "状态为：" + Constants.TaskState_Complete + "-阶段为：" + TaskSectionConstants.COMPLETE);
                    }

                    #endregion

                    #endregion

                    #endregion
                }
                if (executeStatePara.transportTask.CN_S_TASK_TYPE == null)
                    executeStatePara.transportTask.CN_S_TASK_TYPE = "";


 HH.WMS.BLL/HH.WMS.BLL.csproj

@@ -139,6 +139,7 @@
    <Compile Include="Interface\InfK3Request.cs" />
    <Compile Include="Interface\InfOMSRequest.cs" />
    <Compile Include="Interface\OtherSysApi.cs" />
    <Compile Include="MiddleDB\ZCMiddleOperateBll.cs" />
    <Compile Include="MiddleDB\GLMiddleOperateBll.cs" />
    <Compile Include="MoveStock\MoveStockTaskBLL.cs" />
    <Compile Include="MoveStock\TN_WM_B_MOVE_RESULTBLL.cs" />

 HH.WMS.BLL/MiddleDB/ZCMiddleOperateBll.cs

New file
@@ -0,0 +1,70 @@
using HH.WMS.BLL.Pda;
using HH.WMS.Common;
using HH.WMS.Entitys;
using HH.WMS.Entitys.Entitys.Mes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HH.WMS.BLL.MiddleDB
{
    public class ZCMiddleOperateBll : DapperBaseBLL
    {
        public OperateResult TransportSuccess(TN_MES_TASK _req, TN_WM_SERVICE_EXECEntity _serviceExec, string _taskNo)
        {
            return UseTransaction(trans =>
            {
                //反馈mes
                if (_serviceExec.CN_C_SEND_MES == Constants.Y)
                {
                    CreateDapperDAL<TN_MES_TASK>().Update(new
                    {
                        Data_status = _req.Data_status,
                        NeedTrig = _req.NeedTrig,
                        Section = _req.SECTION
                    }, new
                    {
                        TaskNo = _req.task_no
                    }, 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);
                }

                // 关联主任务
                if (!string.IsNullOrEmpty(_taskNo))
                {
                    CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_EXT1 = _req.task_no
                    }, new
                    {
                        CN_S_TASK_NO = _taskNo
                    }, trans);
                }
            });
        }
    }
}

 HH.WMS.BLL/Pda/ZCBLL.cs

@@ -242,20 +242,6 @@
        /// <param name="transportReqs"></param>
        public List<OperateResult> ExecTransferTask(List<TN_MES_TASK> transportReqs)
        {
            var mapStr = JsonHelper.GetValue("workFlowTransType");
            if (string.IsNullOrEmpty(mapStr))
                throw new Exception("未找到配置：workFlowTransType");

            var isEnableAms = new ZCTransferDto();
            var _isEnableAmsStr = JsonHelper.GetValue("isSendAms");
            if (!string.IsNullOrEmpty(_isEnableAmsStr))
            {
                isEnableAms = JsonConvert.DeserializeObject<ZCTransferDto>(_isEnableAmsStr);
                isEnableAms = isEnableAms ?? new ZCTransferDto();
            }

            var workFlowTransType = JsonConvert.DeserializeObject<List<ZCTransferDto>>(mapStr);

            List<OperateResult> ors = new List<OperateResult>();
            if (transportReqs.Any())
            {
@@ -265,128 +251,127 @@
                    string endBit = req.Location_To;

                    string startArea = string.Empty, endArea = string.Empty;
                    //校验起点
                    if (!string.IsNullOrEmpty(startBit))
                    {
                        var _location = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                        {
                            CN_S_LOCATION_CODE = startBit
                        });
                        if (_location == null)
                        {
                            ors.Add(OperateResult.Error("未找到起始货位：" + startBit, req));
                            continue;
                        }
                        startArea = Util.ToString(_location.CN_S_AREA_CODE).Trim();
                    }
                    //校验终点
                    if (!string.IsNullOrEmpty(endBit))
                    {
                        var _location = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                        {
                            CN_S_LOCATION_CODE = endBit
                        });
                        if (_location == null)
                        {
                            ors.Add(OperateResult.Error("未找到终点货位：" + endBit, req));
                            continue;
                        }
                        endArea = Util.ToString(_location.CN_S_AREA_CODE).Trim();
                    }
                    if (string.IsNullOrEmpty(startArea) && string.IsNullOrEmpty(endArea))
                    {
                        ors.Add(OperateResult.Error("起点终点不可同时为空"));
                        continue;
                    }
                    //找作业路径
                    //var workRoute = BLLCreator.Create<TN_AB_B_WORK_AREA_PROBLL>().GetSingleRoute(startArea, endArea);
                    //if (workRoute == null)
                    //{
                    //    ors.Add(OperateResult.Error("未找到作业路径", req));
                    //    continue;
                    //}

                    var workRoute = new TN_AB_B_WORK_AREA_PROEntity();
                    var workRoutes = BLLCreator.Create<TN_AB_B_WORK_AREA_PROBLL>().GetRoute("", startArea, endArea);
                    if (!workRoutes.Any())
                    {
                        ors.Add(OperateResult.Error("未找到作业路径", req));
                        continue;
                    }
                    else
                    {
                        workRoute = workRoutes[0];
                        if (workRoutes.Count > 1)
                        {
                            if (workRoutes.Exists(e => Util.ToString(e.CN_S_TYPE_CODE) == "X6" || Util.ToString(e.CN_S_TYPE_CODE) == "X7"))
                            {
                                if (string.IsNullOrEmpty(req.PROD_NO))
                                {
                                    workRoute = workRoutes.Find(f => f.CN_S_TYPE_CODE == "X6");
                                }
                                else
                                {
                                    workRoute = workRoutes.Find(f => f.CN_S_TYPE_CODE == "X7");
                                }
                            }
                        }
                        if (workRoute == null)
                        {
                            ors.Add(OperateResult.Error("未找到作业路径", req));
                            continue;
                        }
                    }


                    var existsWorkFlow = workFlowTransType.Find(f => f.workFlowCode == workRoute.CN_S_TYPE_CODE);
                    if (existsWorkFlow == null)
                    {
                        ors.Add(OperateResult.Error("未找到作业方向", req));
                        continue;
                    }

                    TN_WM_B_MAKE_TASKEntity makeReq = new TN_WM_B_MAKE_TASKEntity()
                    {
                        CN_S_ITEM_CODE = req.PROD_NO,
                        CN_S_ITEM_NAME = "",
                        CN_S_START_BIT = req.Location_From,
                        CN_S_START_AREA = workRoute.CN_S_START_AREA_CODE,
                        CN_S_END_BIT = req.Location_To,
                        CN_S_END_AREA = workRoute.CN_S_END_AREA_CODE,
                        CN_S_TRAY_CODE = req.TurnCardNum,
                        CN_S_PRIORITY = req.Priority.ToString(),
                        CN_S_WORKFLOW_NAME = WorkFlowName.FlowNameList[existsWorkFlow.workFlowCode],
                        CN_F_QUANTITY = Convert.ToDecimal(req.CURRENT_AMOUNT),
                        CN_S_NEED_AMS = isEnableAms.transferEnableAms,
                        CN_S_ISTRANSPORT = existsWorkFlow.isTransport
                    };

                    var externalRes = new ExternalResponse();
                    if (existsWorkFlow.transType == "In")
                    {
                        try
                        {
                            var res = BLLCreator.Create<ZCBLL>().GLInWorkArea(makeReq);
                            externalRes = JsonConvert.DeserializeObject<ExternalResponse>(res);
                        InWorkAreaEntity inModel = new InWorkAreaEntity();
                        inModel.itemCode = req.PROD_NO;
                        inModel.trayCode = req.TurnCardNum;
                        inModel.priority = req.Priority;
                        inModel.startBit = req.Location_From;
                        inModel.endBit = req.Location_To;
                        inModel.remark = "业务类型：" + req.BUSI_TYPE;

                        OutWorkAreaEntity outModel = new OutWorkAreaEntity();
                        outModel.itemCode = req.PROD_NO;
                        outModel.trayCode = req.TurnCardNum;
                        outModel.priority = req.Priority;
                        outModel.startBit = req.Location_From;
                        outModel.endBit = req.Location_To;
                        outModel.remark = "业务类型：" + req.BUSI_TYPE;

                        // 下一步要执行的阶段
                        string section = NextSection(req);
                        bool needCreateTask = true;
                        string direction = "";

                        if (section == TaskSectionConstants.ERROR)
                        {
                            // "执行失败，MES任务业务类型或阶段不正确"
                            needCreateTask = false;
                        }
                        else if (string.IsNullOrEmpty(section))
                        {
                            needCreateTask = false;
                        }
                        else if (section == TaskSectionConstants.BCP_KTCK)
                        {
                            direction = Constants.Out;
                        }
                        else if (section == TaskSectionConstants.BCP_MTRK)
                        {
                            direction = Constants.In;
                        }
                        else if (section == TaskSectionConstants.CXJ_BCPHK)
                        {
                            direction = Constants.In;
                        }
                        else if (section == TaskSectionConstants.CXJ_KTHK_RECORD)
                        {
                            needCreateTask = false;
                        }
                        else if (section == TaskSectionConstants.CXJ_MTCK)
                        {
                            direction = Constants.Out;
                        }
                        else if (section == TaskSectionConstants.CXJ_KTHK_KTRK)
                        {
                            direction = Constants.In;
                        }
                        else if (section == TaskSectionConstants.DS_BCPKTHK)
                        {
                            direction = Constants.In;
                        }
                        else if (section == TaskSectionConstants.DS_MTCK)
                        {
                            direction = Constants.Out;
                        }
                        // 更新MES任务阶段
                        req.SECTION = section;

                        var externalRes = new ExternalResponse();
                        string taskNo = "";

                        if (needCreateTask)
                        {
                            if (direction == Constants.In)
                            {
                                //传递参数
                                List<InWorkAreaEntity> inWorkAreaEntitys = new List<InWorkAreaEntity>();
                                inWorkAreaEntitys.Add(inModel);

                                try
                                {
                                    Log.Info("入作业区开始，传参：", JsonConvert.SerializeObject(inWorkAreaEntitys));
                                    externalRes = BLLCreator.Create<WmsApiBaseBLL>().InWorkArea(inWorkAreaEntitys);
                                    taskNo = inModel.taskNo;
                        }
                        catch (Exception ex)
                        {
                                    Log.Error("入作业区失败，传参：", JsonConvert.SerializeObject(inWorkAreaEntitys) + ex.ToString());
                            ors.Add(OperateResult.Error("入作业区失败：" + ex.Message, req));
                            continue;
                        }
                    }
                    else
                            else if (direction == Constants.Out)
                    {
                                //传递参数
                                List<OutWorkAreaEntity> outWorkAreaEntitys = new List<OutWorkAreaEntity>();
                                outWorkAreaEntitys.Add(outModel);

                        try
                        {
                            var res = BLLCreator.Create<ZCBLL>().GLOutWorkArea(makeReq);
                            externalRes = JsonConvert.DeserializeObject<ExternalResponse>(res);
                                    Log.Info("出作业区开始，传参：", JsonConvert.SerializeObject(outWorkAreaEntitys));
                                    externalRes = BLLCreator.Create<WmsApiBaseBLL>().OutWorkArea(outWorkAreaEntitys);
                                    taskNo = outModel.taskNo;
                        }
                        catch (Exception ex)
                        {
                                    Log.Error("出作业区失败，传参：", JsonConvert.SerializeObject(outWorkAreaEntitys) + ex.ToString());
                            ors.Add(OperateResult.Error("出作业区失败：" + ex.Message, req));
                            continue;
                        }
                            }
                            else
                            {
                                ors.Add(OperateResult.Error("未知的出入库类型：" + direction, req));
                                continue;
                            }
                        }
                        else
                        {
                            // 不需要创建wms任务的执行流程，标识为成功
                            externalRes.success = true;
                    }

                    var _serviceExec = BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().GetSingleEntity(new
@@ -405,7 +390,7 @@
                            CN_S_ITEM_CODE = req.PROD_NO,
                            CN_S_ITEM_NAME = "",
                            CN_S_TASK_TYPE = "移送",
                            CN_S_TRANS_TYPE = WorkFlowName.FlowNameList[existsWorkFlow.workFlowCode],
                                CN_S_TRANS_TYPE = req.BUSI_TYPE_NAME,
                            CN_S_TRAY_CODE = req.TurnCardNum,
                            CN_N_PRIORITY = req.Priority,
                            CN_S_START_LOCATION = req.Location_From,
@@ -414,29 +399,18 @@
                            CN_C_COMPLETE = Constants.N,
                            CN_C_SEND_MES = Constants.N,
                            CN_F_QUANTITY = Convert.ToDecimal(req.CURRENT_AMOUNT),
                            CN_N_REQUEST_TYPE = 0,//req.RequestType,
                            CN_S_TRAY_TYPE = "0"//req.LoadType
                                CN_N_REQUEST_TYPE = null,
                                CN_S_TRAY_TYPE = ""
                        };
                    }

                    if (!externalRes.success)
                    {
                        //写任务执行表，并回报mes
                        if (externalRes.errCode == "7" || externalRes.errCode == "8")
                        {

                            _serviceExec.CN_C_COMPLETE = Constants.Y;
                            _serviceExec.CN_C_SEND_MES = Constants.Y;
                            _serviceExec.CN_S_MSG = externalRes.errMsg;
                        }
                        else
                        {
                            _serviceExec.CN_C_COMPLETE = Constants.N;
                            _serviceExec.CN_C_SEND_MES = Constants.N;
                            _serviceExec.CN_S_MSG = externalRes.errMsg;
                        }

                        var _or = TransportSuccess(_serviceExec);
                            var _or = BLLCreator.Create<ZCMiddleOperateBll>().TransportSuccess(req, _serviceExec, taskNo);

                        if (!_or.Success)
                        {
@@ -447,17 +421,10 @@
                        }
                        else
                        {
                            if (externalRes.errCode == "7" || externalRes.errCode == "8")
                            {
                                ors.Add(OperateResult.Warning("已反馈至mes，消息： " + externalRes.errMsg, req));
                            }
                            else
                            {
                                ors.Add(OperateResult.Error("externalRes Error： " + externalRes.errMsg, req));
                            }
                        }
                    }
                    else//成功的话写移送任务日志
                        else
                    {
                        var ok = externalRes.okList[0];

@@ -466,7 +433,13 @@
                        _serviceExec.CN_C_COMPLETE = Constants.Y;
                        _serviceExec.CN_C_SEND_MES = Constants.Y;
                        _serviceExec.CN_S_MSG = "下达成功";
                        var _or = TransportSuccess(_serviceExec);

                            req.Data_status = req.SECTION == TaskSectionConstants.COMPLETE ? 2 : 1;
                            req.NeedTrig = Constants.N;
                            req.SECTION = section;

                            var _or = BLLCreator.Create<ZCMiddleOperateBll>().TransportSuccess(req, _serviceExec, taskNo);

                        if (!_or.Success)
                        {
                            ors.Add(OperateResult.Warning("下达成功,更新移送任务日志失败：" + _or.Msg, req));
@@ -474,12 +447,86 @@
                        }
                        ors.Add(OperateResult.Succeed("下达成功", req));
                    }

                        Log.DomainInfo("移送任务 结果", JsonConvert.SerializeObject(ors));
                    }
                    catch (Exception ex)
                    {
                        ors.Add(OperateResult.Error("移送任务失败：" + ex.Message, req));
                        continue;
                    }
                }
                Log.DomainInfo("移送任务 结果", JsonConvert.SerializeObject(ors));
            }
            return ors;
        }
        #endregion

        public string NextSection(TN_MES_TASK task)
        {
            if (task.BUSI_TYPE == "1")
            {
                if (string.IsNullOrEmpty(task.SECTION))
                    return TaskSectionConstants.BCP_KTCK;
                else if (task.SECTION == TaskSectionConstants.BCP_KTCK)
                    return TaskSectionConstants.BCP_MTRK;
                else if (task.SECTION == TaskSectionConstants.BCP_MTRK)
                    return TaskSectionConstants.COMPLETE;
                else
                    return TaskSectionConstants.ERROR;
            }
            else if (task.BUSI_TYPE == "2")
            {
                if (string.IsNullOrEmpty(task.SECTION))
                    return TaskSectionConstants.CXJ_BCPHK;
                else if (task.SECTION == TaskSectionConstants.CXJ_BCPHK)
                    return TaskSectionConstants.COMPLETE;
                else
                    return TaskSectionConstants.ERROR;
            }
            else if (task.BUSI_TYPE == "3")
            {
                if (string.IsNullOrEmpty(task.SECTION))
                    return TaskSectionConstants.CXJ_KTHK_RECORD;
                else if (task.SECTION == TaskSectionConstants.CXJ_KTHK_RECORD)
                    return TaskSectionConstants.COMPLETE;
                else
                    return TaskSectionConstants.ERROR;
            }
            else if (task.BUSI_TYPE == "4")
            {
                if (string.IsNullOrEmpty(task.SECTION))
                    return TaskSectionConstants.CXJ_MTCK;
                else if (task.SECTION == TaskSectionConstants.CXJ_MTCK)
                    return TaskSectionConstants.CXJ_KTHK_KTRK;
                else if (task.SECTION == TaskSectionConstants.CXJ_KTHK_KTRK)
                    return TaskSectionConstants.COMPLETE;
                else
                    return TaskSectionConstants.ERROR;
            }
            else if (task.BUSI_TYPE == "5")
            {
                if (string.IsNullOrEmpty(task.SECTION))
                    return TaskSectionConstants.DS_BCPKTHK;
                else if (task.SECTION == TaskSectionConstants.DS_BCPKTHK)
                    return TaskSectionConstants.COMPLETE;
                else
                    return TaskSectionConstants.ERROR;
            }
            else if (task.BUSI_TYPE == "6")
            {
                if (string.IsNullOrEmpty(task.SECTION))
                    return TaskSectionConstants.DS_MTCK;
                else if (task.SECTION == TaskSectionConstants.DS_MTCK)
                    return TaskSectionConstants.COMPLETE;
                else
                    return TaskSectionConstants.ERROR;
            }
            else
            {
                return TaskSectionConstants.ERROR;
            }
        }

        #region 判断是否在工作时间
        /// <summary>
@@ -524,9 +571,6 @@

                //传递参数
                List<InWorkAreaEntity> inWorkAreaEntitys = new List<InWorkAreaEntity>();





                InWorkAreaEntity model = new InWorkAreaEntity();
@@ -783,267 +827,364 @@
        {
            try
            {
                //取未执行、完成一半、完成部分的自管任务
                //取未执行的自管任务
                var tasks = BLLCreator.CreateDapper<TN_WM_TASKEntity>().GetList(new
                {
                    CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                    CN_S_STATE = new List<string>() { Constants.TaskState_NoExecuted, Constants.TaskState_CompleteHalf, Constants.TaskState_CompletePart }
                    CN_S_STATE = new List<string>() { Constants.TaskState_NoExecuted, Constants.TaskState_CompleteHalf }
                });

                // 接驳位配置
                var mes_tasks = BLLCreator.CreateDapper<TN_MES_TASK>().GetList(new
                {
                    task_no = tasks.ConvertAll(t => t.CN_S_EXT1).ToList()
                });

                var connectBitStr = JsonHelper.GetValue("connectBit");
                if (string.IsNullOrEmpty(connectBitStr))
                    throw new Exception("未找到配置：connectBit");

                var connectBits = JsonConvert.DeserializeObject<List<ConnectBitDto>>(connectBitStr);

                List<OperateResult> ors = new List<OperateResult>();
                foreach (var task in tasks)
                {
                    try
                    {
                        var connectBits = JsonConvert.DeserializeObject<List<ConnectBitDto>>(connectBitStr);

                        OperateResult or = OperateResult.Error("未知错误");

                        #region 半成品

                        #region 空托出库

                        if (task.CN_S_EXT3 == TaskSectionConstants.BCP_KTCK)
                        var mes_task = mes_tasks.FirstOrDefault(t => t.task_no == task.CN_S_EXT1);
                        if (mes_task == null)
                        {
                            // 空托出库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.KTCK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建两条并行子任务
                                or = ExecBCP_KTCK_Add(task, connectBit);
                            ors.Add(OperateResult.Error("从TN_MES_TASK表中未找到此任务的来源MES任务，任务编号：" + task.CN_S_TASK_NO));
                            continue;
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.BCP_KTCK_SUB_1)
                        // 出库主任务是同时下两条子任务
                        if (mes_task.SECTION == TaskSectionConstants.BCP_KTCK ||
                            mes_task.SECTION == TaskSectionConstants.CXJ_MTCK ||
                            mes_task.SECTION == TaskSectionConstants.DS_MTCK)
                            {
                                // 执行第一条子任务
                                or = ExecBCP_KTCK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.BCP_KTCK_SUB_2)
                            string tasktype = mes_task.SECTION == TaskSectionConstants.BCP_KTCK ? ConnectBitConstants.KTCK : mes_task.SECTION == TaskSectionConstants.CXJ_MTCK ? ConnectBitConstants.MTCK : mes_task.SECTION == TaskSectionConstants.DS_MTCK ? ConnectBitConstants.DSCK : "";
                            //立库货位
                            string lkBit = task.CN_S_START_BIT;

                            var locationBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                            {
                                // 执行第二条任务
                                or = ExecBCP_KTCK_Sub2(task, connectBit);
                            }
                                CN_S_LOCATION_CODE = lkBit
                            });
                            if (locationBit == null)
                                throw new Exception("未找到立库货位：" + lkBit);
                            var _bit = connectBits.Find(f => f.tasktype == tasktype);
                            if (_bit == null)
                                throw new Exception("未找到配置类型为：" + tasktype + "的接驳位");

                            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 + "存在未执行完的任务");

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

                            //赋值接驳位
                            task.CN_S_CONNECT_BIT = _bit.bit;
                            task.CN_S_EXT2 = _bit.readybit;

                            string taskNo1 = task.CN_S_TASK_NO + "_1";
                            //创建第一个任务
                            TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
                            {
                                CN_S_TASK_NO = taskNo1,
                                CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                                CN_S_START_BIT = task.CN_S_START_BIT,
                                CN_S_END_BIT = task.CN_S_CONNECT_BIT,
                                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_END_AREA = connectBit.CN_S_AREA_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_LG,
                                CN_S_TASK_TYPE = "转运"
                            };
                            string taskNo2 = task.CN_S_TASK_NO + "_2";
                            //创建第二个任务
                            TN_WM_TASKEntity taskEntity2 = new TN_WM_TASKEntity()
                            {
                                CN_S_TASK_NO = taskNo2,
                                CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                                CN_S_START_BIT = task.CN_S_CONNECT_BIT,
                                CN_S_END_BIT = task.CN_S_END_BIT,
                                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_END_AREA = task.CN_S_END_AREA,
                                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_AGV,
                                CN_S_TASK_TYPE = "转运"
                            };
                            var or = UseTransaction(trans =>
                            {
                                //增加子任务
                                CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1, trans);
                                //更新接驳位状态
                                CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                                {
                                    CN_S_LOCATION_STATE = Constants.Location_State_InLock
                                }, new
                                {
                                    CN_S_LOCATION_CODE = taskEntity1.CN_S_END_BIT
                                }, trans);
                                // 更新主任务接驳位 状态置为执行中 记录接驳位和准备点
                                CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                                {
                                    CN_S_CONNECT_BIT = task.CN_S_CONNECT_BIT,
                                    CN_S_EXT1 = task.CN_S_EXT1,
                                    CN_S_STATE = Constants.TaskState_Executing
                                }, new
                                {
                                    CN_S_TASK_NO = task.CN_S_TASK_NO
                                }, trans);
                                //立库任务  需要调用wcs接口
                                // 发送Wcs任务
                                Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "任务信息：" + JsonConvert.SerializeObject(taskEntity1));
                                OperateResult re = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(taskEntity1);
                                Log.Detail(LogType.LogPara("调用WCS接口执行任务"), "执行结果：" + JsonConvert.SerializeObject(re));
                                if (!re.Success)
                                {
                                    throw new Exception(re.Msg);
                        }

                                //增加子任务
                                CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2, trans);
                                //更新准备点状态
                                CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                                {
                                    CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                                }, new
                                {
                                    CN_S_LOCATION_CODE = taskEntity2.CN_S_START_BIT
                                }, trans);

                                //agv任务
                                re = new OtherSysApi().SendAmsCreateTask(taskEntity2);
                                if (!re.Success)
                                {
                                    throw new Exception(re.Msg);
                                }
                            });
                            if (!or.Success) throw new Exception(or.Msg);
                        }
                        else
                        {
                            //未执行表示第一个任务
                            if (task.CN_S_STATE == Constants.TaskState_NoExecuted)
                            {
                                //立库货位
                                string lkBit = string.Empty;
                                //根据任务类型判断立库货位
                                if (task.CN_S_TASK_TYPE == Constants.Out)
                                {
                                    lkBit = task.CN_S_START_BIT;
                                }
                                else if (task.CN_S_TASK_TYPE == Constants.In)
                                {
                                    lkBit = task.CN_S_END_BIT;
                                }
                                else
                                {
                                    throw new Exception("自管任务任务类型不正确");
                                }

                                var locationBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                                {
                                    CN_S_LOCATION_CODE = lkBit
                                });
                                if (locationBit == null)
                                    throw new Exception("未找到立库货位：" + lkBit);
                                var _bit = connectBits.Find(f => f.tunnel == Util.ToString(locationBit.CN_S_ROADWAY).Trim());
                                if (_bit == null)
                                    throw new Exception("未找到配置巷道：" + locationBit.CN_S_ROADWAY + "的接驳位");

                                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 + "存在未执行完的任务");

                                //赋值接驳位
                                task.CN_S_CONNECT_BIT = _bit.bit;

                                string taskNo = task.CN_S_TASK_NO + "_1";
                                //创建第一个任务
                                TN_WM_TASKEntity taskEntity = new TN_WM_TASKEntity()
                                {
                                    CN_S_TASK_NO = taskNo,
                                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                                    CN_S_START_BIT = task.CN_S_START_BIT,
                                    CN_S_END_BIT = task.CN_S_CONNECT_BIT,
                                    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_END_AREA = connectBit.CN_S_AREA_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 = task.CN_S_TASK_TYPE == Constants.Out ? Constants.TaskFlag_LG : Constants.TaskFlag_AGV,
                                    CN_S_TASK_TYPE = "转运"
                                };
                                var or = UseTransaction(trans =>
                                {
                                    //增加子任务
                                    CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity, trans);
                                    //更新接驳位状态
                                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                                    {
                                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                                    }, new
                                    {
                                        CN_S_LOCATION_CODE = taskEntity.CN_S_END_BIT
                                    }, trans);
                                    // 更新主任务接驳位 状态置为执行中
                                    CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                                    {
                                        CN_S_CONNECT_BIT = task.CN_S_CONNECT_BIT,
                                        CN_S_STATE = Constants.TaskState_Executing
                                    }, new
                                    {
                                        CN_S_TASK_NO = task.CN_S_TASK_NO
                                    }, trans);
                                    //立库任务  需要调用wcs接口
                                    if (taskEntity.CN_S_TASK_FLAG == Constants.TaskFlag_LG)
                                    {
                                        //to do...
                                        #region 待测试
                                        //OperateResult re = new OtherSysApi().SendWcsCreateTask(taskEntity, _bit);
                                        //if (!re.Success)
                                        //{
                                        //    throw new Exception(re.Msg);
                                        //}
                        #endregion
                                    }
                                    else//agv任务
                                    {
                                        //OperateResult re = new OtherSysApi().SendAmsCreateTask(taskEntity);
                                        //if (!re.Success)
                                        //{
                                        //    throw new Exception(re.Msg);
                                        //}
                                    }
                                });
                                if (!or.Success) throw new Exception(or.Msg);
                            }
                            else//执行一半的任务，开始创建第二个任务
                            {
                                string taskNo = task.CN_S_TASK_NO + "_2";
                                var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
                                {
                                    CN_S_LOCATION_CODE = task.CN_S_CONNECT_BIT
                                });
                                var _bit = connectBits.Find(f => f.tunnel == Util.ToString(connectBit.CN_S_ROADWAY).Trim());
                                if (_bit == null)
                                    throw new Exception("未找到配置巷道：" + connectBit.CN_S_ROADWAY + "的接驳位");
                                //创建第二个任务
                                TN_WM_TASKEntity taskEntity = new TN_WM_TASKEntity()
                                {
                                    CN_S_TASK_NO = taskNo,
                                    CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                                    CN_S_START_BIT = task.CN_S_CONNECT_BIT,
                                    CN_S_END_BIT = task.CN_S_END_BIT,
                                    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_END_AREA = task.CN_S_END_AREA,
                                    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 = task.CN_S_TASK_TYPE == Constants.Out ? Constants.TaskFlag_AGV : Constants.TaskFlag_LG,
                                    CN_S_TASK_TYPE = "转运"
                                };

                        #region 满托入库
                                var or = UseTransaction(trans =>
                                {
                                    //增加子任务
                                    CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity, trans);
                                    //更新接驳位状态
                                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                                    {
                                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                                    }, new
                                    {
                                        CN_S_LOCATION_CODE = taskEntity.CN_S_START_BIT
                                    }, trans);
                                    // 更新主任务接驳位 状态置为执行中
                                    CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                                    {
                                        CN_S_STATE = Constants.TaskState_Executing
                                    }, new
                                    {
                                        CN_S_TASK_NO = task.CN_S_TASK_NO
                                    }, trans);

                        else if (task.CN_S_EXT3 == TaskSectionConstants.BCP_MTRK)
                                    //立库任务  需要调用wcs接口
                                    if (taskEntity.CN_S_TASK_FLAG == Constants.TaskFlag_LG)
                        {
                            // 满托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第一条子任务
                                or = ExecBCP_MTRK_AddSub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.BCP_MTRK_SUB_1)
                            {
                                // 执行第一条子任务
                                or = ExecBCP_MTRK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.BCP_MTRK_SUB_2)
                            {
                                // 执行第二条子任务
                                or = ExecBCP_MTRK_Sub2(task, connectBit);
                            }
                        }
                        else if (task.CN_S_EXT3 == TaskSectionConstants.BCP_MTRK_SECOND)
                        {
                            // 满托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第二条子任务
                                or = ExecBCP_MTRK_AddSub2(task, connectBit);
                            }
                        }

                                        //to do...
                                        #region 待测试
                                        //OperateResult re = new OtherSysApi().SendWcsCreateTask(taskEntity, _bit);
                                        //if (!re.Success)
                                        //{
                                        //    throw new Exception(re.Msg);
                                        //}
                        #endregion

                        #endregion

                        #region 成型机

                        #region 半成品回库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_BCPHK)
                        {
                            // 满托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第一条子任务
                                ExecCXJ_BCPHK_AddSub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_1)
                                    else//agv任务
                            {
                                // 执行第一条子任务
                                ExecCXJ_BCPHK_Sub1(task, connectBit);
                                        //OperateResult re = new OtherSysApi().SendAmsCreateTask(taskEntity);
                                        //if (!re.Success)
                                        //{
                                        //    throw new Exception(re.Msg);
                                        //}
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_2)
                            {
                                // 执行第二条子任务
                                ExecCXJ_BCPHK_Sub2(task, connectBit);
                            }
                        }
                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_BCPHK_SECOND)
                        {
                            // 满托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第二条子任务
                                ExecCXJ_BCPHK_AddSub2(task, connectBit);
                                });
                                if (!or.Success) throw new Exception(or.Msg);
                            }
                        }

                        #endregion

                        #region 空托回库

                        #region 记录

                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_KTHK_RECORD)
                        {
                            // 只用于记录
                            // 在同一线边货位的满托出库任务完成后执行
                        }

                        #endregion

                        #region 空托入库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_KTHK_KTRK)
                        {
                            // 空托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.KTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第一条子任务
                                ExecCXJ_KTHK_KTRK_AddSub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_1)
                            {
                                // 执行第一条子任务
                                ExecCXJ_KTHK_KTRK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_2)
                            {
                                // 执行第二条子任务
                                ExecCXJ_KTHK_KTRK_Sub2(task, connectBit);
                            }
                        }
                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_KTHK_KTRK_SECOND)
                        {
                            // 空托入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.KTRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第二条子任务
                                ExecCXJ_KTHK_KTRK_AddSub2(task, connectBit);
                            }
                        }

                        #endregion

                        #endregion

                        #region 满托出库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.CXJ_MTCK)
                        {
                            // 满托出库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTCK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建两条并行子任务
                                or = ExecCXJ_MTCK_Add(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_MTCK_SUB_1)
                            {
                                // 执行第一条子任务
                                or = ExecCXJ_MTCK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_MTCK_SUB_2)
                            {
                                // 执行第二条任务
                                or = ExecCXJ_MTCK_Sub2(task, connectBit);
                            }
                        }

                        #endregion

                        #endregion

                        #region 带束

                        #region 半成品/空托回库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.DS_BCPKTHK)
                        {
                            // 带束入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.DSRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第一条子任务
                                ExecDS_BCPKTHK_AddSub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_1)
                            {
                                // 执行第一条子任务
                                ExecDS_BCPKTHK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.CXJ_BCPHK_SUB_2)
                            {
                                // 执行第二条子任务
                                ExecDS_BCPKTHK_Sub2(task, connectBit);
                            }
                        }
                        else if (task.CN_S_EXT3 == TaskSectionConstants.DS_BCPKTHK_SECOND)
                        {
                            // 带束入库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.DSRK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建第二条子任务
                                ExecDS_BCPKTHK_AddSub2(task, connectBit);
                            }
                        }

                        #endregion

                        #region 满托出库

                        else if (task.CN_S_EXT3 == TaskSectionConstants.DS_MTCK)
                        {
                            // 带束出库的接驳位
                            var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.DSCK);
                            if (task.CN_S_EXT2 == TaskFlagConstants.ROOT)
                            {
                                // 创建两条并行子任务
                                or = ExecCXJ_MTCK_Add(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.DS_MTCK_SUB_1)
                            {
                                // 执行第一条子任务
                                or = ExecCXJ_MTCK_Sub1(task, connectBit);
                            }
                            else if (task.CN_S_EXT2 == TaskFlagConstants.DS_MTCK_SUB_2)
                            {
                                // 执行第二条任务
                                or = ExecCXJ_MTCK_Sub2(task, connectBit);
                            }
                        }

                        #endregion

                        #endregion
                        ors.Add(OperateResult.Succeed("生成成功"));
                    }
                    catch (Exception ex)
                    {
@@ -1055,100 +1196,6 @@
            catch (Exception ex)
            {
                Log.DomainInfo("SelfManageTask Error", ex.Message);
            }
        }

        /// <summary>
        /// 遍历中间表，根据业务类型创建WMS任务
        /// </summary>
        public void ExecTransferTask()
        {
            // 已接收待处理任务
            var receiveTasks = BLLCreator.CreateDapper<TN_MES_TASK>().GetList(new TN_MES_TASK
            {
                NeedTrig = "Y"
            }).OrderBy(t => t.CreateDate).ToList();

            List<OperateResult> ors = new List<OperateResult>();

            foreach (var task in receiveTasks)
            {
                try
                {
                    // 从mongo中获取货位相关的信息 - 起始货位
                    AutoBomLocationEntity start_location = CreateDAL<TN_AB_STOCK_LOCATIONDAL>().GetModel(task.Location_From);
                    // 从mongo中获取货位相关的信息 - 终点货位
                    AutoBomLocationEntity end_location = CreateDAL<TN_AB_STOCK_LOCATIONDAL>().GetModel(task.Location_To);

                    // 主任务执行流程中的起始阶段
                    string section = "";
                    switch (task.BUSI_TYPE)
                    {
                        case "1":
                            section = TaskSectionConstants.BCP_KTCK;
                            break;
                        case "2":
                            section = TaskSectionConstants.CXJ_BCPHK;
                            break;
                        case "3":
                            section = TaskSectionConstants.CXJ_KTHK_RECORD;
                            break;
                        case "4":
                            section = TaskSectionConstants.CXJ_MTCK;
                            break;
                        case "5":
                            section = TaskSectionConstants.DS_BCPKTHK;
                            break;
                        case "6":
                            section = TaskSectionConstants.DS_MTCK;
                            break;
                    }
                    // 创建WMS主任务
                    TN_WM_TASKEntity taskEntity = new TN_WM_TASKEntity()
                    {
                        CN_S_TASK_NO = task.task_no,
                        CN_S_TRAY_CODE = task.TurnCardNum,
                        CN_S_STATE = Constants.TaskState_NoExecuted,
                        CN_S_BF_TASK_NO = "",
                        CN_S_AF_TASK_NO = "",
                        CN_S_STOCK_CODE = start_location.CN_S_STOCK_CODE,
                        CN_S_START_AREA = start_location.CN_S_AREA_CODE,
                        CN_S_START_BIT = start_location.CN_S_LOCATION_CODE,
                        CN_S_END_AREA = end_location.CN_S_AREA_CODE,
                        CN_S_END_BIT = end_location.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 = "",
                        CN_S_EXT2 = TaskFlagConstants.ROOT,
                        CN_S_EXT3 = section
                    };
                    UseTransaction(trans =>
                    {
                        // 增加WMS主任务
                        OperateResult re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity);
                        if (!re.Success)
                            throw new Exception(re.Msg);
                        // 更新TN_MES_TASK状态
                        CreateDapperDAL<TN_MES_TASK>().Update(new
                        {
                            NeedTrig = "N"
                        }, new { task_no = task.task_no }, trans);
                        if (!re.Success)
                            throw new Exception(re.Msg);
                    });

                    ors.Add(OperateResult.Succeed("生成成功"));
                }
                catch (Exception ex)
                {
                    ors.Add(OperateResult.Error(ex.Message));
                }
                Log.DomainInfo("ExecTransferTask", JsonConvert.SerializeObject(ors));
            }
        }

@@ -2866,21 +2913,18 @@
        /// 任务完成
        /// </summary>
        public static string COMPLETE = "任务完成";
        public static string ERROR = "执行失败";

        #region 半成品

        /// <summary>
        /// 半成品-空托出库
        /// </summary>
        public static string BCP_KTCK = "空托出库";
        public static string BCP_KTCK = "半成品-空托出库";
        /// <summary>
        /// 半成品-满托入库
        /// </summary>
        public static string BCP_MTRK = "半成品-满托入库";
        /// <summary>
        /// 半成品-满托入库-第二阶段
        /// </summary>
        public static string BCP_MTRK_SECOND = "半成品-满托入库-第二阶段";

        #endregion

@@ -2890,11 +2934,6 @@
        /// 成型机-半成品回库
        /// </summary>
        public static string CXJ_BCPHK = "成型机-半成品回库";

        /// <summary>
        /// 成型机-半成品回库-第二阶段
        /// </summary>
        public static string CXJ_BCPHK_SECOND = "成型机-半成品回库-第二阶段";
        /// <summary>
        /// 成型机-空托回库-记录阶段
        /// </summary>
@@ -2904,17 +2943,9 @@
        /// </summary>
        public static string CXJ_KTHK_KTRK = "成型机-空托回库-入库阶段";
        /// <summary>
        /// 成型机-空托回库-入库阶段-第二阶段
        /// </summary>
        public static string CXJ_KTHK_KTRK_SECOND = "成型机-空托回库-入库阶段-第二阶段";
        /// <summary>
        /// 成型机-满托出库
        /// </summary>
        public static string CXJ_MTCK = "成型机-满托出库";
        /// <summary>
        /// 成型机-空托入库
        /// </summary>
        public static string CXJ_KTRK = "成型机-空托入库";

        #endregion

@@ -2924,10 +2955,6 @@
        /// 带束-半成品/空托回库
        /// </summary>
        public static string DS_BCPKTHK = "成型机带束-半成品/空托回库";
        /// <summary>
        /// 带束-半成品/空托回库-第二阶段
        /// </summary>
        public static string DS_BCPKTHK_SECOND = "成型机带束-半成品/空托回库-第二阶段";
        /// <summary>
        /// 带束-满托出库
        /// </summary>

 HH.WMS.Common/Constants.cs

@@ -495,10 +495,6 @@
        /// 任务状态-完成一半
        /// </summary>
        public static readonly string TaskState_CompleteHalf = "完成一半";
        /// <summary>
        /// 任务状态-完成部分
        /// </summary>
        public static readonly string TaskState_CompletePart = "部分完成";
        #endregion
        #region 任务执行反馈结果
        /// <summary>

 HH.WMS.Common/JsonHelper.cs

@@ -660,8 +660,8 @@
                    using (JsonTextReader reader = new JsonTextReader(file))
                    {
                        JObject o = (JObject)JToken.ReadFrom(reader);
                        var value = o[name].ToString();
                        return value.Replace("\r\n", "");
                        var value = o[name]?.ToString();
                        return value?.Replace("\r\n", "")??"";
                    }
                }
            }

 HH.WMS.Entitys/Entitys/Mes/TN_MES_TASK.cs

@@ -146,5 +146,39 @@
        /// </summary>
        [Column("BUSI_TYPE")]
        public string BUSI_TYPE { get; set; }

        public string BUSI_TYPE_NAME
        {
            get
            {
                string name = "未知";
                switch (BUSI_TYPE)
                {
                    case "1":
                        name = "半成品满托入库";
                        break;
                    case "2":
                        name = "成型机半成品回库";
                        break;
                    case "3":
                        name = "成型机空桶回库";
                        break;
                    case "4":
                        name = "成型机满托出库";
                        break;
                    case "5":
                        name = "成型机带束回库";
                        break;
                    case "":
                        name = "成型机带束满托出库";
                        break;
                }
                return name;
            }
        }
        /// <summary>
        /// 任务阶段
        /// </summary>
        public string SECTION { get; set; }
    }
}

 HH.WMS.Entitys/Entitys/TN_WM_TASKEntity.cs

@@ -115,18 +115,18 @@
        [Column("CN_S_END_AREA_TYPE")]
        public string CN_S_END_AREA_TYPE { get; set; }
        /// <summary>
        /// 扩展字段1 主任务编号
        /// 扩展字段1 MES任务编号
        /// </summary>
        [Column("CN_S_EXT1")]
        public string CN_S_EXT1 { get; set; }
        /// <summary>
        /// 扩展字段2 任务标识
        /// 扩展字段2 准备点
        /// </summary>
        [Column("CN_S_EXT2")]
        public string CN_S_EXT2 { get; set; }

        /// <summary>
        /// 扩展字段3 任务执行阶段
        /// 扩展字段3
        /// </summary>
        [Column("CN_S_EXT3")]
        public string CN_S_EXT3 { get; set; }

 HH.WMS.WebApi/Config.json

@@ -1,237 +1,4 @@
{
  "isSendAms": {
    "moveStockEnableAms": "N", //移库是否启用ams
    "transferEnableAms": "N" //移送是否启用ams
  },
  //生胶移库（一楼中转区到二楼中转区）
  "transferOfRawRubber": {
    "itemCode": "6972879772026",
    "itemName": "生胶名称",
    "transferMax": 10, //二楼可存放转运的最大值，大于等于该值服务暂停执行
    "startArea": "F1_SJZZQ", //一楼中转区域
    "endArea": "F2_SJZZQ", //二楼中转区域
    "startTime": "8:30", //几点开始
    "endTime": "10:30" //几点结束
  },
  //终炼胶移库
  "transferOfFinalRubber": {
    "itemCode": "6972879772002",
    "itemName": "终炼胶",
    "transferMax": 10, //二楼可存放转运的最大值，大于等于该值服务暂停执行
    "startArea": "ZLJCFQ", //终炼胶存放区
    "endArea": "DCJHCQ", //大车间缓存区
    "startTime": "8:30", //几点开始
    "endTime": "10:30" //几点结束
  },
  "workFlowTransType": [
    {
      "workFlowCode": "S1",
      "workFlowName": "生胶中转搬运",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "S2",
      "workFlowName": "生胶中转移库",
      "transType": "Out",
      "isTransport": "Y"
    },
    {
      "workFlowCode": "S3",
      "workFlowName": "密炼机叫料",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "S4",
      "workFlowName": "密炼机工位空托退回",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "S5",
      "workFlowName": "生胶小盘料退回",
      "transType": "In",
      "isTransport": "N"
    },

    {
      "workFlowCode": "X1",
      "workFlowName": "小料秤叫料",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "X2",
      "workFlowName": "小料秤叫料取空托",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "X3",
      "workFlowName": "小料秤搬运",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "X4",
      "workFlowName": "小料秤搬运取空托",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "X5",
      "workFlowName": "密炼产线呼叫小料",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "X6",
      "workFlowName": "密炼生产线取空托",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "X7",
      "workFlowName": "小料小盘料退回",
      "transType": "In",
      "isTransport": "N"
    },

    {
      "workFlowCode": "M1",
      "workFlowName": "母胶收皮下线",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "M2",
      "workFlowName": "收皮设备呼叫空托",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "M3",
      "workFlowName": "母胶密炼机叫料",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "M4",
      "workFlowName": "密炼机备料补货",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "M5",
      "workFlowName": "母胶小盘料退回",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "M6",
      "workFlowName": "密炼机叫料返空托",
      "transType": "In"
    },
    {
      "workFlowCode": "Z1",
      "workFlowName": "终炼胶胶盘下线",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "Z2",
      "workFlowName": "终炼胶呼叫空托",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "Z3",
      "workFlowName": "终炼胶移库",
      "transType": "Out",
      "isTransport": "Y"
    },
    {
      "workFlowCode": "Z4",
      "workFlowName": "终炼胶下工序叫料",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "Z5",
      "workFlowName": "终炼胶备料补货",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "Z6",
      "workFlowName": "终炼胶小盘料退回",
      "transType": "In",
      "isTransport": "N"
    },

    {
      "workFlowCode": "T1",
      "workFlowName": "胎面生产线下线",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "T2",
      "workFlowName": "空栅车运回",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "T3",
      "workFlowName": "成型机叫料",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "T4",
      "workFlowName": "成型机叫料回空托",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "T5",
      "workFlowName": "余料格栅车退回",
      "transType": "In",
      "isTransport": "N"
    },

    {
      "workFlowCode": "L1",
      "workFlowName": "压延生产线下线",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "L2",
      "workFlowName": "空卷轴运回",
      "transType": "In",
      "isTransport": "N"
    },
    {
      "workFlowCode": "L3",
      "workFlowName": "直裁/斜裁生产线叫料",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "L4",
      "workFlowName": "直裁/斜裁空托排出呼叫",
      "transType": "Out",
      "isTransport": "N"
    },
    {
      "workFlowCode": "L5",
      "workFlowName": "余料帘布退回",
      "transType": "In",
      "isTransport": "N"
    }
  ],
  //接驳位
  "connectBit": [
    {
@@ -240,6 +7,7 @@
    },
    {
      "bit": "接驳位货位",
      "readybit": "准备点货位",
      "tasktype": "带束出库"
    },
    {
@@ -253,6 +21,7 @@
    },
    {
      "bit": "接驳位货位",
      "readybit": "准备点货位",
      "tasktype": "满托出库"
    },
    {

 HH.WMS.WebApi/Controllers/WmsApiController.cs

@@ -1087,10 +1087,45 @@
        public object InWorkArea(dynamic jsonData)
        {
            var logPara = LogType.LogPara("任务下发");
            Log.Detail(logPara, "HCZCSendTask:任务下发传递参数：" + jsonData.ToString());

            ZCReceiveTaskEntity sendTaskEntity = JsonConvert.DeserializeObject<ZCReceiveTaskEntity>(jsonData.ToString());

            if(string.IsNullOrEmpty(sendTaskEntity.BUSI_TYPE))
            {
                Log.Detail(logPara, "ZCSendTask任务下发失败，缺少参数BUSI_TYPE。" + jsonData.ToString());
                return new
                {
                    success = false,
                    code = -1,
                    lastTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    message = "缺少参数BUSI_TYPE"
                };
            }
            if (string.IsNullOrEmpty(sendTaskEntity.Location_From) && string.IsNullOrEmpty(sendTaskEntity.Location_To))
            {
                Log.Detail(logPara, "ZCSendTask任务下发失败，起点和终点同时为空。" + jsonData.ToString());
                return new
                {
                    success = false,
                    code = -1,
                    lastTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    message = "缺少起点Location_From或终点Location_To"
                };
            }
            if (string.IsNullOrEmpty(sendTaskEntity.task_no))
            {
                Log.Detail(logPara, "ZCSendTask任务下发失败，缺少参数task_no。" + jsonData.ToString());
                return new
                {
                    success = false,
                    code = -1,
                    lastTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    message = "缺少参数task_no"
                };
            }

            Log.Detail(logPara, "ZCSendTask任务下发传递参数：" + jsonData.ToString());

            //调用ReceiveTask方法保存至中间库
            var result = BLLCreator.Create<WmsApiBaseBLL>().ReceiveTask(sendTaskEntity);
            return new

 HH.WMS.WebApi/Extension/ExecTransferTask.cs

@@ -25,11 +25,27 @@
        public void Run(object source, ElapsedEventArgs elapsedEventArgs)
        {
            try
            {  //防止Timer重入
            {
                //防止Timer重入
                lock (locko)
                {
                    // 使用TN_MES_TASK临时表中接收的MES任务，创建WMS任务
                    BLLCreator.Create<ZCBLL>().ExecTransferTask();                    
                    var transportReqs = BLLCreator.CreateDapper<TN_MES_TASK>().GetList(new
                    {
                        NeedTrig = Constants.Y
                    }).OrderBy(o => o.CreateDate).ToList();

                    var serviceExecs = BLLCreator.CreateDapper<TN_WM_SERVICE_EXECEntity>().GetList(new
                    {
                        CN_C_COMPLETE = Constants.N,
                        CN_S_TASK_TYPE = "移送"
                    });

                    transportReqs = transportReqs.FindAll(f => !serviceExecs.Exists(e => e.CN_S_TASK_NO == f.task_no));

                    if (transportReqs.Any())
                    {
                        BLLCreator.Create<ZCBLL>().ExecTransferTask(transportReqs);
                    }
                }
            }
            catch (Exception ex)