半成品入库-空托出库和满托入库的基本流程

zhao

2021-06-24 02ca96debc6056275d58e55d97f7885a195542d0

半成品入库-空托出库和满托入库的基本流程

 HH.WMS.BLL/External/WmsApiBaseBLL.cs

@@ -1512,15 +1512,10 @@

            #endregion

            string tno = executeStatePara.transportTask.CN_S_TASK_NO;
            string tno = executeStatePara.transportTask.CN_S_TASK_NO.Trim();
            if (tno.IndexOf('_') > 0)
            {
                string TopNo = tno.Substring(0, tno.IndexOf("_"));
                string navNo = tno.Substring(tno.IndexOf("_") + 1);
                if (navNo == "2")
                {
                    tno = TopNo;
                }
                tno = tno.Split('_')[0];
            }
            // 获取主任务
            var task = BLLCreator.CreateDapper<TN_WM_TASKEntity>().GetSingleEntity(new
@@ -1546,7 +1541,97 @@
                if (taskNo.IndexOf('_') > 0)
                {
                    string fatherNo = taskNo.Substring(0, taskNo.IndexOf("_"));
                    string hzNo = taskNo.Substring(taskNo.IndexOf("_") + 1);
                    string childNo = taskNo.Substring(taskNo.IndexOf("_") + 1);

                    #region 海潮中策

                    // 半成品满托入库流程
                    if (task.CN_S_EXT1 == BusinessTypeConstants.BCP_MTRK)
                    {
                        // 空托出库第一条子任务
                        if (executeStatePara.transportTask.CN_S_EXT2 == "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);
                        }
                        // 空托出库第二条子任务
                        if (executeStatePara.transportTask.CN_S_EXT2 == "ktck_sub_2")
                        {
                            // 主任务状态置为完成部分
                            // 主任务的子任务标识置空
                            // 主任务阶段置为半成品-满托入库
                            CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                            {
                                CN_S_STATE = Constants.TaskState_CompletePart,
                                CN_S_EXT2 = "",
                                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);
                            // 终点货位状态改为:满
                            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 + "，更新接驳位状态-货位号：" + task.CN_S_CONNECT_BIT + "状态为：" + Constants.Location_State_Normal + "，更新准备点状态-货位号：" + executeStatePara.transportTask.CN_S_START_BIT + "状态为：" + Constants.Location_State_Normal + "，更新终点状态-货位号：" + executeStatePara.transportTask.CN_S_END_BIT + "状态为：" + Constants.Location_State_Full);
                            // 在主循环中创建后继任务
                        }
                        // 满托入库第一条子任务
                        if (executeStatePara.transportTask.CN_S_EXT2 == "bcp_mtrk_sub_1")
                        {
                            // 主任务状态置为完成部分
                            // 主任务的子任务标识置为bcp_mtrk_sub_1_completed
                            CreateDAL<DapperDAL<TN_WM_TASKEntity>>().Update(new
                            {
                                CN_S_STATE = Constants.TaskState_CompletePart,
                                CN_S_EXT2 = "bcp_mtrk_sub_1_completed"
                            }, new { CN_S_TASK_NO = task.CN_S_TASK_NO }, trans);
                            // 在主循环中创建后继任务
                        }
                        // 满托入库第二条子任务
                        if (executeStatePara.transportTask.CN_S_EXT2 == "bcp_mtrk_sub_2")
                        {

                        }
                    }

                    #endregion


                    //A到B的AGV搬运任务
                    if (hzNo == "1")
                    {

 HH.WMS.BLL/Interface/OtherSysApi.cs

@@ -466,18 +466,35 @@
        {
            List<JObject> sendParams = new List<JObject>();
            JObject sendParam = new JObject();
            sendParam.Add("taskNo", model.CN_S_TASK_NO);
            sendParam.Add("lpnNo", model.CN_S_TRAY_CODE);
            sendParam.Add("taskType", model.CN_S_TASK_TYPE == Constants.In?"10": model.CN_S_TASK_TYPE == Constants.Out?"20":"");
            sendParam.Add("taskPrty", model.CN_N_PRIORITY);
            sendParam.Add("laneNo", bit.tunnel);
            sendParam.Add("frmLocate", model.CN_S_START_BIT);
            sendParam.Add("toLocate", model.CN_S_END_BIT);
            sendParam.Add("wmsOrdeNO", "");
            sendParam.Add("createTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));

            JObject sendData = new JObject();
            // 托盘编码
            sendData.Add("PalletCode", model.CN_S_TRAY_CODE);
            // 任务编码
            sendData.Add("TaskCode", model.CN_S_TASK_NO);
            // 起始设备号
            sendData.Add("EquipmentS_Id", "");
            // 目的设备号
            sendData.Add("EquipmentE_Id", "");
            // 起始货位编码
            sendData.Add("PositionS_Id", model.CN_S_START_BIT);
            // 目的货位编码
            sendData.Add("PositionE_Id", model.CN_S_END_BIT);
            // 起始深度
            sendData.Add("StartDepth", "");
            // 目的深度
            sendData.Add("EndDepth", "1");
            sendData.Add("Remarks", "");
            sendData.Add("Description", "");
            //请求类型
            sendParam.Add("request_type", model.CN_S_TASK_TYPE == Constants.In ? "10" : model.CN_S_TASK_TYPE == Constants.Out ? "20" : "");
            //请求数据集合
            sendParam.Add("request_data", sendData);
            
            sendParams.Add(sendParam);
            string sendData = JsonConvert.SerializeObject(sendParams);
            Log.Info("===>发送任务给WCS", sendData);

            string sendDatas = JsonConvert.SerializeObject(sendParams);
            Log.Info("===>发送任务给WCS", sendDatas);
            string postOmsData = JsonConvert.SerializeObject(sendParams);
            string result = WebApiManager.HttpWcs_Post("api/InformWcs/SendTask", postOmsData);
            Log.Info("===>WCS返回结果", result);
@@ -504,4 +521,9 @@
            }
        }
    }

    public class WcsCreateTaskParam
    {
        public string PalletCode;
    }
}

 HH.WMS.BLL/Pda/ZCBLL.cs

@@ -779,28 +779,84 @@
        }
        #endregion

        // CN_S_EXT1:业务类型
        // CN_S_EXT2:子任务标识
        // CN_S_EXT3:任务执行阶段
        public void SelfManageTask()
        {
            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 }
                    CN_S_STATE = new List<string>() { Constants.TaskState_NoExecuted, Constants.TaskState_CompleteHalf, Constants.TaskState_CompletePart }
                });

                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 connectBitStr = JsonHelper.GetValue("connectBit");
                        if (string.IsNullOrEmpty(connectBitStr))
                            throw new Exception("未找到配置：connectBit");
                        var connectBits = JsonConvert.DeserializeObject<List<ConnectBitDto>>(connectBitStr);
                        OperateResult or = OperateResult.Error("未知错误");
                        if (task.CN_S_EXT1 == BusinessTypeConstants.BCP_MTRK)// 半成品满托入库流程
                        {
                            // -空托出库阶段
                            if (task.CN_S_EXT3 == TaskSectionConstants.KTCK)
                            {
                                var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.KTCK);
                                // 创建两条并行子任务
                                if (string.IsNullOrEmpty(task.CN_S_EXT2))
                                {
                                    or = ExecKTCK(task, connectBit);
                                }
                                // sub_1 -用于向WCS发送空托->接驳位的出库任务
                                else if (task.CN_S_EXT2 == "ktck_sub_1")
                                {
                                    or = ExecKTCK_Sub1(task, connectBit);
                                }
                                // sub_2 - 用于向AMS发送准备点->终点的空托搬运任务
                                else if (task.CN_S_EXT2 == "ktck_sub_2")
                                {
                                    or = ExecKTCK_Sub2(task, connectBit);
                                }
                            }
                            else if (task.CN_S_EXT3 == TaskSectionConstants.BCP_MTRK)
                            {
                                var connectBit = connectBits.Find(f => f.tasktype == ConnectBitConstants.MTRK);
                                // 创建第一条子任务
                                if (string.IsNullOrEmpty(task.CN_S_EXT2))
                                {
                                    or = ExecBCP_MTRK_AddSub1(task, connectBit);
                                }
                                // 执行第一条子任务
                                else if (task.CN_S_EXT2 == "bcp_mtrk_sub_1")
                                {
                                    or = ExecBCP_MTRK_Sub1(task, connectBit);
                                }
                                // 创建第二条子任务
                                else if (task.CN_S_EXT2 == "bcp_mtrk_sub_1_completed")
                                {
                                    or = ExecBCP_MTRK_AddSub2(task, connectBit);
                                }
                                // 执行第二条子任务
                                else if (task.CN_S_EXT2 == "bcp_mtrk_sub_2")
                                {
                                    or = ExecBCP_MTRK_Sub2(task, connectBit);
                                }
                            }
                        }
                        else
                        {
                            or = OperateResult.Error("未知的业务类型：task.CN_S_EXT1=" + task.CN_S_EXT1);
                        }

                        continue;

                        //未执行表示第一个任务
                        if (task.CN_S_STATE == Constants.TaskState_NoExecuted)
                        {
@@ -1043,6 +1099,24 @@
                    // 从mongo中获取货位相关的信息 - 终点货位
                    AutoBomLocationEntity end_location = CreateDAL<TN_AB_STOCK_LOCATIONDAL>().GetModel(task.Location_To);

                    // 主任务执行流程中的起始阶段
                    string section = "";
                    switch (task.BUSI_TYPE)
                    {
                        case "1":
                            section = TaskSectionConstants.KTCK;
                            break;
                        case "2":
                            break;
                        case "3":
                            break;
                        case "4":
                            break;
                        case "5":
                            break;
                        case "6":
                            break;
                    }
                    // 创建WMS主任务
                    TN_WM_TASKEntity taskEntity = new TN_WM_TASKEntity()
                    {
@@ -1063,6 +1137,9 @@
                        CN_T_MODIFY = DateTime.Now,
                        CN_S_REMARK = "",
                        CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                        CN_S_EXT1 = task.BUSI_TYPE,
                        CN_S_EXT2 = "",
                        CN_S_EXT3 = section
                    };
                    UseTransaction(trans =>
                    {
@@ -1088,5 +1165,463 @@
                Log.DomainInfo("ExecTransferTask", JsonConvert.SerializeObject(ors));
            }
        }

        #region 半成品-满托入库

        #region 空托出库

        /// <summary>
        /// 创建空托出库并行子任务
        /// </summary>
        public OperateResult ExecKTCK(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            // 空托出库和满托入库是反向的
            var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
            {
                CN_S_LOCATION_CODE = bit.bit
            });
            var readyBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
            {
                CN_S_LOCATION_CODE = bit.readybit
            });
            if (connectBit == null)
                throw new Exception("未找到接驳位货位：" + bit.bit);
            if (connectBit.CN_S_LOCATION_STATE != Constants.Location_State_Normal)
                throw new Exception("接驳位：" + bit.bit + "存在未执行完的任务");

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

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

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

            try
            {
                UseTransaction(trans =>
                {
                    // 创建空托出库子任务1
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity1);
                    if (!re.Success)
                        throw new Exception(re.Msg);
                    // 创建空托出库子任务2
                    re = CreateDapperDAL<TN_WM_TASKEntity>().Add(taskEntity2);
                    if (!re.Success)
                        throw new Exception(re.Msg);

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

            return re;
        }
        /// <summary>
        /// 执行空托出库的第一条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name=""></param>
        /// <returns></returns>
        public OperateResult ExecKTCK_Sub1(TN_WM_TASKEntity task1, ConnectBitDto connectBit)
        {
            OperateResult or = OperateResult.Error("未知错误");
            try
            {
                UseTransaction(trans =>
                {
                    // 接驳位 预入库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_InLock
                    }, new { CN_S_LOCATION_CODE = connectBit.bit }, trans);
                    // 子任务1状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task1.CN_S_TASK_NO }, trans);
                    // 发送Wcs任务
                    or = BLLCreator.Create<OtherSysApi>().SendWcsCreateTask(task1, connectBit);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行空托出库子任务1失败，任务编号=" + task1.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }
        /// <summary>
        /// 执行空托出库的第二条子任务
        /// </summary>
        /// <param name="task"></param>
        /// <param name="connectBit"></param>
        /// <returns></returns>
        public OperateResult ExecKTCK_Sub2(TN_WM_TASKEntity task2, ConnectBitDto connectBit)
        {
            OperateResult or = OperateResult.Error("未知错误");
            try
            {
                UseTransaction(trans =>
                {
                    // 准备点 预出库锁定
                    CreateDapperDAL<TN_WM_LOCATION_EXTEntity>().Update(new
                    {
                        CN_S_LOCATION_STATE = Constants.Location_State_OutLock
                    }, new { CN_S_LOCATION_CODE = connectBit.readybit }, trans);
                    // 子任务2状态置为执行中
                    or = CreateDapperDAL<TN_WM_TASKEntity>().Update(new
                    {
                        CN_S_STATE = Constants.TaskState_Executing
                    }, new { CN_S_TASK_NO = task2.CN_S_TASK_NO }, trans);
                    // 发送Ams任务
                    or = BLLCreator.Create<OtherSysApi>().SendAmsTask(task2);
                });
            }
            catch (Exception ex)
            {
                OperateResult.Error("执行空托出库子任务2失败，任务编号=" + task2.CN_S_TASK_NO + "，错误信息：" + ex.Message);
            }
            return or;
        }

        #endregion

        #region 满托入库

        #region 主任务

        /// <summary>
        /// 创建 半成品-满托入库 子任务1
        /// </summary>
        public OperateResult ExecBCP_MTRK_AddSub1(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
            {
                CN_S_LOCATION_CODE = bit.bit
            });

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

            // 工位->接驳位
            TN_WM_TASKEntity taskEntity1 = new TN_WM_TASKEntity()
            {
                CN_S_TASK_NO = task.CN_S_TASK_NO + "_3",
                CN_S_TRAY_CODE = task.CN_S_TRAY_CODE,
                CN_S_STATE = Constants.TaskState_NoExecuted,
                CN_S_BF_TASK_NO = "",
                CN_S_AF_TASK_NO = "",
                CN_S_STOCK_CODE = task.CN_S_STOCK_CODE,
                CN_S_START_AREA = task.CN_S_START_AREA,
                CN_S_START_BIT = task.CN_S_START_BIT,
                CN_S_END_AREA = connectBit.CN_S_AREA_CODE,
                CN_S_END_BIT = connectBit.CN_S_LOCATION_CODE,
                CN_N_PRIORITY = 1,
                CN_S_CREATOR = "sys",
                CN_S_CREATOR_BY = "sys",
                CN_T_CREATE = DateTime.Now,
                CN_T_MODIFY = DateTime.Now,
                CN_S_REMARK = "",
                CN_S_TASK_FLAG = Constants.TaskFlag_ZG,
                CN_S_EXT1 = task.CN_S_EXT1,
                CN_S_EXT2 = "bcp_mtrk_sub_1"
            };
            OperateResult re = OperateResult.Error("未知错误");

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

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

            return re;
        }
        /// <summary>
        /// 创建 半成品-满托入库 子任务2
        /// </summary>
        public OperateResult ExecBCP_MTRK_AddSub2(TN_WM_TASKEntity task, ConnectBitDto bit)
        {
            var connectBit = BLLCreator.CreateDapper<TN_WM_LOCATION_EXTEntity>().GetSingleEntity(new
            {
                CN_S_LOCATION_CODE = bit.bit
            });

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

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

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

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

            return re;
        }

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

        #endregion

        #endregion

        #endregion
    }

    /// <summary>
    /// 配置文件中的常量定义
    /// </summary>
    public class ConnectBitConstants
    {
        /// <summary>
        /// 带束入库
        /// </summary>
        public static string DSRK = "带束入库";
        /// <summary>
        /// 带束出库
        /// </summary>
        public static string DSCK = "带束出库";
        /// <summary>
        /// 满托入库
        /// </summary>
        public static string MTRK = "满托入库";
        /// <summary>
        /// 空托出库
        /// </summary>
        public static string KTCK = "空托出库";
        /// <summary>
        /// 满托出库
        /// </summary>
        public static string MTCK = "满托出库";
        /// <summary>
        /// 空托入库
        /// </summary>
        public static string KTRK = "空托入库";
    }

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

    public class TaskSectionConstants
    {
        /// <summary>
        /// 空托出库
        /// </summary>
        public static string KTCK = "空托出库";
        /// <summary>
        /// 半成品-满托入库
        /// </summary>
        public static string BCP_MTRK = "半成品-满托入库";
    }
}

 HH.WMS.Common/Constants.cs

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

 HH.WMS.Entitys/Dto/ConnectBitDto.cs

@@ -10,5 +10,7 @@
    {
        public string tunnel { get; set; }
        public string bit { get; set; }
        public string readybit { get; set; }
        public string tasktype { get; set; }
    }
}

 HH.WMS.WebApi/Config.json

@@ -248,6 +248,7 @@
    },
    {
      "bit": "接驳位货位",
      "readybit": "准备点货位",
      "tasktype": "空托出库"
    },
    {

 HH.WMS.WebApi/HH.WMS.WebApi.csproj

@@ -446,6 +446,7 @@
          <SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile>
        </WebProjectProperties>
      </FlavorProperties>
      <UserProperties config_1json__JsonSchema="" />
    </VisualStudio>
  </ProjectExtensions>
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.