修复取消订单和更改终点货区流程与国自AGV交互的部分细节问题

kazelee

2025-06-19 0e829f4a5321c10900e1f4130a80f2e8c804a08e

修复取消订单和更改终点货区流程与国自AGV交互的部分细节问题

 .vs/HH.WCS.Mobox3.AnGang/FileContentIndex/88ff7190-7304-453c-8d3d-4144359d0c9e.vsidx

Binary files differ

 api/ApiHelper.cs

@@ -3,6 +3,8 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using HH.WCS.Mobox3.AnGang.dispatch;
using HH.WCS.Mobox3.AnGang.models;
using HH.WCS.Mobox3.AnGang.util;
using HH.WCS.Mobox3.AnGang.wms;
@@ -105,11 +107,11 @@
            }
        }

        //internal static string GenerateNo(string snType, string prefix) {
        //    var id = SYSHelper.GetSerialNumber(snType, prefix);
        //    var date = DateTime.Now.ToString("yyMMdd");
        //    return $"TN{date}{id.ToString().PadLeft(4, '0')}";
        //}
        internal static string GenerateNo(string snType, string prefix) {
            var id = SYSHelper.GetSerialNumber(snType, prefix);
            var date = DateTime.Now.ToString("yyMMdd");
            return $"{prefix}{date}-{id.ToString().PadLeft(5, '0')}"; // 形如：CN250525-00011
        }

        /// <summary>
        /// PDA选择终点货位
@@ -183,13 +185,13 @@
                using (var tran = db.Ado.UseTran()) {
                    if (db.Updateable<TN_Task>(task).UpdateColumns(a => a.S_END_LOC).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(7, $"任务{task.S_CODE}修改失败，修改终点位置为{endLoc.S_CODE}");
                        return BuildSimpleResult(500, $"任务{task.S_CODE}修改失败，修改终点位置为{endLoc.S_CODE}");
                    }

                    if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(7, $"任务{task.S_CODE}修改失败，修改终点位置为{endLoc.S_CODE}");
                        return BuildSimpleResult(500, $"任务{task.S_CODE}修改失败，修改终点位置为{endLoc.S_CODE}");
                    }

                    tran.CommitTran();
@@ -239,6 +241,8 @@

                LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
                LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁

                var res = GZRobot.QueryInteractInfo(3);

                using (var tran = db.Ado.UseTran()) {
                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
@@ -353,16 +357,16 @@
                    task.N_B_STATE = 4;
                    task.S_B_STATE = "取消";

                    var starloc = db.Queryable<TN_Location>().First(a => a.S_CODE == task.S_START_LOC);
                    var startloc = db.Queryable<TN_Location>().First(a => a.S_CODE == task.S_START_LOC);
                    var endloc = db.Queryable<TN_Location>().First(a => a.S_CODE == task.S_END_LOC);
                    //var locCnt = db.Queryable<TN_Loc_Container>().First(a => a.S_CNTR_CODE == task.S_CNTR_CODE);
                    //var cg = db.Queryable<TN_CG_Detail>().First(a => a.S_CNTR_CODE == task.S_CNTR_CODE);

                    if (starloc != null) {
                        starloc.N_LOCK_STATE = 0;
                        starloc.S_LOCK_STATE = "无";
                    if (startloc != null) {
                        startloc.N_LOCK_STATE = 0;
                        startloc.S_LOCK_STATE = "无";
                        //starloc.N_CURRENT_NUM = 0;
                        starloc.T_MODIFY = System.DateTime.Now;
                        startloc.T_MODIFY = System.DateTime.Now;
                    }

                    if (endloc != null) {
@@ -372,45 +376,45 @@
                        endloc.T_MODIFY = System.DateTime.Now;
                    }

                    if (!int.TryParse(task.S_EQ_TASK_CODE, out var code)) {
                        return BuildSimpleResult(1, $"当前任务{task.S_CODE}没有找到对应的国自AGV orderId！");
                    }
                    var res = GZRobot.CancelGZOrder(code);
                    if (!res) {
                        return BuildSimpleResult(2, $"国自AGV取消任务失败！");
                    }

                    using (var tran = db.Ado.UseTran()) {
                        if (db.Updateable<TN_Location>(starloc).ExecuteCommand() <= 0) {
                        if (db.Updateable<TN_Location>(startloc).ExecuteCommand() <= 0) {
                            tran.RollbackTran();

                            info = $"任务{task.S_CODE}取消失败";

                            return BuildSimpleResult(0, info);
                            info = $"任务{task.S_CODE}取消失败：修改起点货位锁状态失败";
                            return BuildSimpleResult(500, info);
                        }

                        if (endloc != null) {
                            if (db.Updateable<TN_Location>(endloc).ExecuteCommand() <= 0) {
                                tran.RollbackTran();

                                info = $"任务{task.S_CODE}取消失败";

                                return BuildSimpleResult(0, info);
                                info = $"任务{task.S_CODE}取消失败：修改终点货位锁状态失败";
                                return BuildSimpleResult(500, info);
                            }
                        }

                        if (db.Updateable<TN_Task>(task).ExecuteCommand() <= 0) {
                            if (db.Updateable<TN_Location>(endloc).ExecuteCommand() <= 0) {
                                tran.RollbackTran();

                                info = $"任务{task.S_CODE}取消失败";

                                return BuildSimpleResult(0, info);
                            }
                            return BuildSimpleResult(500, info);
                        }

                        tran.CommitTran();

                        info = $"任务{task.S_CODE}取消成功";

                        return BuildSimpleResult(0, info);
                    }

                }
                else {
                    return BuildSimpleResult(3, $"只有任务号状态为 等待 或 已推送 的任务才能取消");

                    // return CancelTaskIfForced(model, task); // 备用函数，如果甲方要求任务执行中也取消，再调用
                }

            }
@@ -419,271 +423,268 @@
            }
        }

        public static SimpleResult CreateCountPlan(CreateCountPlanInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            try {

                var countPlan = new TN_Count_Plan() {
                    S_CP_NO = GenerateNo("盘点计划", "CP"),
                    S_TYPE = model.countType,
                };

                if (model.countType == "货位") {
                    countPlan.S_LOC_CODE = model.targetId;
                }
                else if (model.countType == "物料") {
                    countPlan.S_ITEM_CODE = model.targetId;
                }
                else {
                    return BuildSimpleResult(2, $"创建盘点计划失败：不合法的盘点类型 '{model.countType}'");
        public static SimpleResult CancelTaskIfForced(CancleTaskInfo model, TN_Task task) {
            return BuildSimpleResult(3, $"只有任务号状态为 等待 或 已推送 的任务才能取消");
                }

                if (db.Insertable<TN_Count_Plan>(countPlan).ExecuteCommand() <= 0) {
                    return BuildSimpleResult(2, "创建盘点计划失败");
                }
        //public static SimpleResult CreateCountPlan(CreateCountPlanInfo model) {
        //    var db = new SqlHelper<object>().GetInstance();
        //    try {

                return BuildSimpleResult(0, "创建盘点计划成功");
        //        var countPlan = new TN_Count_Plan() {
        //            S_CP_NO = GenerateNo("盘点计划", "CP"),
        //            S_TYPE = model.countType,
        //        };

            }
            catch (Exception ex) {
        //        if (model.countType == "货位") {
        //            countPlan.S_LOC_CODE = model.targetId;
        //        }
        //        else if (model.countType == "物料") {
        //            countPlan.S_ITEM_CODE = model.targetId;
        //        }
        //        else {
        //            return BuildSimpleResult(2, $"创建盘点计划失败：不合法的盘点类型 '{model.countType}'");
        //        }

                return BuildSimpleResult(1, ex.Message);
            }
        }
        //        if (db.Insertable<TN_Count_Plan>(countPlan).ExecuteCommand() <= 0) {
        //            return BuildSimpleResult(2, "创建盘点计划失败");
        //        }

        public static SimpleResult CreateCountOrder(CreateCountOrderInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var info = "";
            try {
                var countPlan = db.Queryable<TN_Count_Plan>()
                    .Where(a => a.S_CP_NO == model.planId).First();
        //        return BuildSimpleResult(0, "创建盘点计划成功");

                if (countPlan == null) {
                    return BuildSimpleResult(2, $"盘点计划单号 '{model.planId}' 不存在");
                }
        //    }
        //    catch (Exception ex) {

                var countOrder = new TN_Count_Order() {
                    S_CP_NO = model.planId,
                    S_COUNT_NO = GenerateNo("盘点单", "CN"),
                };
        //        return BuildSimpleResult(1, ex.Message);
        //    }
        //}

                var countDetailList = new List<TN_Count_CG_Detail>();
                if (countPlan.S_TYPE == "货位") {
                    var cgDetail = db.Queryable<TN_Location, TN_Loc_Container, TN_CG_Detail>
                        ((l, c, d) => l.S_CODE == c.S_LOC_CODE && c.S_CNTR_CODE == d.S_CNTR_CODE)
                        .Where(l => l.S_CODE == countPlan.S_LOC_CODE)
                        .Select((l, c, d) => d).First();
        //public static SimpleResult CreateCountOrder(CreateCountOrderInfo model) {
        //    var db = new SqlHelper<object>().GetInstance();
        //    var info = "";
        //    try {
        //        var countPlan = db.Queryable<TN_Count_Plan>()
        //            .Where(a => a.S_CP_NO == model.planId).First();

                    var countDetail = new TN_Count_CG_Detail {
                        S_COUNT_NO = countOrder.S_COUNT_NO,
                        S_CNTR_CODE = cgDetail.S_CNTR_CODE,
                        S_ITEM_CODE = cgDetail.S_ITEM_CODE,
                    };
        //        if (countPlan == null) {
        //            return BuildSimpleResult(2, $"盘点计划单号 '{model.planId}' 不存在");
        //        }

                    countDetailList.Add(countDetail);
                }
                else if (countPlan.S_TYPE == "物料") {
                    var cgDetailList = db.Queryable<TN_CG_Detail>()
                        .Where(d => d.S_ITEM_CODE == countPlan.S_ITEM_CODE).ToList();
        //        var countOrder = new TN_Count_Order() {
        //            S_CP_NO = model.planId,
        //            S_COUNT_NO = GenerateNo("盘点单", "CN"),
        //        };

                    foreach (var cgDetail in cgDetailList) {
                        var countDetail = new TN_Count_CG_Detail {
                            S_COUNT_NO = countOrder.S_COUNT_NO,
                            S_CNTR_CODE = cgDetail.S_CNTR_CODE,
                            S_ITEM_CODE = cgDetail.S_ITEM_CODE,
                        };
        //        var countDetailList = new List<TN_Count_CG_Detail>();
        //        if (countPlan.S_TYPE == "货位") {
        //            var cgDetail = db.Queryable<TN_Location, TN_Loc_Container, TN_CG_Detail>
        //                ((l, c, d) => l.S_CODE == c.S_LOC_CODE && c.S_CNTR_CODE == d.S_CNTR_CODE)
        //                .Where(l => l.S_CODE == countPlan.S_LOC_CODE)
        //                .Select((l, c, d) => d).First();

                        countDetailList.Add(countDetail);
                    }
                }
                else {
                    return BuildSimpleResult(3, $"计划单'{model.planId}'的类型{countPlan.S_TYPE}不合法");
                }
        //            var countDetail = new TN_Count_CG_Detail {
        //                S_COUNT_NO = countOrder.S_COUNT_NO,
        //                S_CNTR_CODE = cgDetail.S_CNTR_CODE,
        //                S_ITEM_CODE = cgDetail.S_ITEM_CODE,
        //            };

                using (var tran = db.Ado.UseTran()) {
                    if (db.Insertable<TN_Count_Order>(countOrder).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = "创建盘点单失败";
                        return BuildSimpleResult(2, info);
                    }
        //            countDetailList.Add(countDetail);
        //        }
        //        else if (countPlan.S_TYPE == "物料") {
        //            var cgDetailList = db.Queryable<TN_CG_Detail>()
        //                .Where(d => d.S_ITEM_CODE == countPlan.S_ITEM_CODE).ToList();

                    if (db.Insertable<TN_Count_CG_Detail>(countDetailList).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = "创建盘点单明细失败";
                        return BuildSimpleResult(3, info); 
                    }
        //            foreach (var cgDetail in cgDetailList) {
        //                var countDetail = new TN_Count_CG_Detail {
        //                    S_COUNT_NO = countOrder.S_COUNT_NO,
        //                    S_CNTR_CODE = cgDetail.S_CNTR_CODE,
        //                    S_ITEM_CODE = cgDetail.S_ITEM_CODE,
        //                };

                    tran.CommitTran();
                }
        //                countDetailList.Add(countDetail);
        //            }
        //        }
        //        else {
        //            return BuildSimpleResult(3, $"计划单'{model.planId}'的类型{countPlan.S_TYPE}不合法");
        //        }

                return BuildSimpleResult(0, "创建盘点单成功");
            }
            catch (Exception ex) {
        //        using (var tran = db.Ado.UseTran()) {
        //            if (db.Insertable<TN_Count_Order>(countOrder).ExecuteCommand() <= 0) {
        //                tran.RollbackTran();
        //                info = "创建盘点单失败";
        //                return BuildSimpleResult(2, info);
        //            }

                return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
            }
        }
        //            if (db.Insertable<TN_Count_CG_Detail>(countDetailList).ExecuteCommand() <= 0) {
        //                tran.RollbackTran();
        //                info = "创建盘点单明细失败";
        //                return BuildSimpleResult(3, info); 
        //            }

        public static SimpleResult CountProduct(CountProductInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            try {
                var cgDetail = db.Queryable<TN_CG_Detail>()
                    .Where(d => d.S_CNTR_CODE == model.cntrCode).First();
        //            tran.CommitTran();
        //        }

                if (cgDetail == null) {
                    return BuildSimpleResult(2, $"找不到容器号'{model.cntrCode}'对应的物料");
                }
        //        return BuildSimpleResult(0, "创建盘点单成功");
        //    }
        //    catch (Exception ex) {

                var countDiff = new TN_Count_Diff {
                    S_CNTR_CODE = cgDetail.S_CNTR_CODE,
                    F_QTY = cgDetail.F_QTY,
                    F_ACTUAL_QTY = model.qty
                };
        //        return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
        //    }
        //}

                if (db.Insertable<TN_Count_Diff>(countDiff).ExecuteCommand() <= 0) {
                    return BuildSimpleResult(3, $"插入盘点差异表失败");
                }
        //public static SimpleResult CountProduct(CountProductInfo model) {
        //    var db = new SqlHelper<object>().GetInstance();
        //    try {
        //        var cgDetail = db.Queryable<TN_CG_Detail>()
        //            .Where(d => d.S_CNTR_CODE == model.cntrCode).First();

                return BuildSimpleResult(0, "盘点差异完成");
        //        if (cgDetail == null) {
        //            return BuildSimpleResult(2, $"找不到容器号'{model.cntrCode}'对应的物料");
        //        }

            }
            catch (Exception ex) {
                return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
            }
        }
        //        var countDiff = new TN_Count_Diff {
        //            S_CNTR_CODE = cgDetail.S_CNTR_CODE,
        //            F_QTY = cgDetail.F_QTY,
        //            F_ACTUAL_QTY = model.qty
        //        };

        internal static string GenerateNo(string snType, string prefix) {
            var id = SYSHelper.GetSerialNumber(snType, prefix);
        //        if (db.Insertable<TN_Count_Diff>(countDiff).ExecuteCommand() <= 0) {
        //            return BuildSimpleResult(3, $"插入盘点差异表失败");
        //        }
            
            var date = DateTime.Now.ToString("yyMMdd");
            return $"{prefix}{date}-{id.ToString().PadLeft(5, '0')}"; // 形如：CN250525-00011
        }
        //        return BuildSimpleResult(0, "盘点差异完成");

        /// <summary>
        /// 盘点理货出库(WMS)
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResult CheckOutbound(CheckOutboundInfo model) {
            var taskName = TaskName.盘点理货出库;
            var db = new SqlHelper<object>().GetInstance();
        //    }
        //    catch (Exception ex) {
        //        return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
        //    }
        //}

            try {
                // 起点位置：取放货区（有货物、没有锁、已启用）
                var startLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.startLoc && a.N_CURRENT_NUM == 1 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && Settings.Areas[0].Contains(a.S_AREA_CODE));
                if (startLoc == null) {
                    return BuildSimpleResult(2, $"起点位置 {model.startLoc} 不符合出库条件");
                }
        ///// <summary>
        ///// 盘点理货出库(WMS)
        ///// </summary>
        ///// <param name="model"></param>
        ///// <returns></returns>
        //internal static SimpleResult CheckOutbound(CheckOutboundInfo model) {
        //    var taskName = TaskName.盘点理货出库;
        //    var db = new SqlHelper<object>().GetInstance();

                var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
                if (locCntrRel == null) {
                    return BuildSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
                }
        //    try {
        //        // 起点位置：取放货区（有货物、没有锁、已启用）
        //        var startLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.startLoc && a.N_CURRENT_NUM == 1 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && Settings.Areas[0].Contains(a.S_AREA_CODE));
        //        if (startLoc == null) {
        //            return BuildSimpleResult(2, $"起点位置 {model.startLoc} 不符合出库条件");
        //        }

                // 终点位置：货架（没有货物，没有锁）
                var endLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.endLoc && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y");
                if (endLoc == null) {
                    return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                }
        //        var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
        //        if (locCntrRel == null) {
        //            return BuildSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
        //        }

                var cntID = locCntrRel.S_CNTR_CODE;
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntID, taskName);
                LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
                LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁
        //        // 终点位置：货架（没有货物，没有锁）
        //        var endLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.endLoc && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y");
        //        if (endLoc == null) {
        //            return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
        //        }

                using (var tran = db.Ado.UseTran()) {
                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}");
                    }
        //        var cntID = locCntrRel.S_CNTR_CODE;
        //        var task = WCSHelper.BuildTask(startLoc, endLoc, cntID, taskName);
        //        LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
        //        LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁

                    if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }
        //        using (var tran = db.Ado.UseTran()) {
        //            if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
        //                it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() <= 0) {
        //                tran.RollbackTran();
        //                return BuildSimpleResult(500,
        //                    $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}");
        //            }

                    if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }
        //            if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
        //                it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() <= 0) {
        //                tran.RollbackTran();
        //                return BuildSimpleResult(500,
        //                    $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
        //            }

                    tran.CommitTran();
                    return BuildSimpleResult(0,
                        $"生成 {taskName} 成功，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                }
            }
            catch (Exception ex) {
                return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
            }
        }
        //            if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
        //                tran.RollbackTran();
        //                return BuildSimpleResult(500,
        //                    $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
        //            }

        /// <summary>
        /// 盘点理货回库(WMS)
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResult CheckInbound(CheckInboundInfo model) {
            var taskName = TaskName.盘点理货回库;
            var db = new SqlHelper<object>().GetInstance();
        //            tran.CommitTran();
        //            return BuildSimpleResult(0,
        //                $"生成 {taskName} 成功，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
        //        }
        //    }
        //    catch (Exception ex) {
        //        return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
        //    }
        //}

            try {
                // 起点位置：取放货区（有货物、没有锁、已启用）
                var startLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.startLoc && a.N_CURRENT_NUM == 1 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && Settings.Areas[0].Contains(a.S_AREA_CODE));
                if (startLoc == null) {
                    return BuildSimpleResult(2, $"起点位置 {model.startLoc} 不符合回库条件");
                }
        ///// <summary>
        ///// 盘点理货回库(WMS)
        ///// </summary>
        ///// <param name="model"></param>
        ///// <returns></returns>
        //internal static SimpleResult CheckInbound(CheckInboundInfo model) {
        //    var taskName = TaskName.盘点理货回库;
        //    var db = new SqlHelper<object>().GetInstance();

                var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
                if (locCntrRel == null) {
                    return BuildSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
                }
        //    try {
        //        // 起点位置：取放货区（有货物、没有锁、已启用）
        //        var startLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.startLoc && a.N_CURRENT_NUM == 1 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && Settings.Areas[0].Contains(a.S_AREA_CODE));
        //        if (startLoc == null) {
        //            return BuildSimpleResult(2, $"起点位置 {model.startLoc} 不符合回库条件");
        //        }

                // 终点位置：货架（没有货物，没有锁）
                var endLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.endLoc && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y");
                if (endLoc == null) {
                    return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                }
        //        var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
        //        if (locCntrRel == null) {
        //            return BuildSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
        //        }

                var cntID = locCntrRel.S_CNTR_CODE;
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntID, taskName);
                LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
                LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁
        //        // 终点位置：货架（没有货物，没有锁）
        //        var endLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.endLoc && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y");
        //        if (endLoc == null) {
        //            return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
        //        }

                using (var tran = db.Ado.UseTran()) {
                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}");
                    }
        //        var cntID = locCntrRel.S_CNTR_CODE;
        //        var task = WCSHelper.BuildTask(startLoc, endLoc, cntID, taskName);
        //        LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
        //        LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁

                    if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }
        //        using (var tran = db.Ado.UseTran()) {
        //            if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
        //                it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() <= 0) {
        //                tran.RollbackTran();
        //                return BuildSimpleResult(500,
        //                    $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}");
        //            }

                    if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }
        //            if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
        //                it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() <= 0) {
        //                tran.RollbackTran();
        //                return BuildSimpleResult(500,
        //                    $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
        //            }

                    tran.CommitTran();
                    return BuildSimpleResult(0,
                        $"生成 {taskName} 成功，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                }
            }
            catch (Exception ex) {
                return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
            }
        }
        //            if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
        //                tran.RollbackTran();
        //                return BuildSimpleResult(500,
        //                    $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
        //            }

        //            tran.CommitTran();
        //            return BuildSimpleResult(0,
        //                $"生成 {taskName} 成功，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
        //        }
        //    }
        //    catch (Exception ex) {
        //        return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
        //    }
        //}

        public static ErpResult InboundDataSync(InboundDataSyncInfo model) {
            //return BuildErpResult(1, "测试");

 api/DebugController.cs

@@ -100,157 +100,6 @@
            return gzResults;
        }

        ///// <summary>
        ///// 初始化数据库
        ///// </summary>
        ///// <returns></returns>
        //[HttpPost]
        //[Route("CreateDatabase")]
        //public string CreateDatabase(CoverInfo model) {
        //    try {
        //        var db = new SqlHelper<object>().GetInstance();
        //        var cover = model.IsCover;

        //        var entityTypes = new Type[] {
        //            typeof(TN_CAR_IN),
        //            typeof(TN_CG_Detail),
        //            typeof(TN_Container),
        //            typeof(TN_Loc_Container),
        //            typeof(TN_Location),
        //            typeof(TN_Task),
        //            typeof(TN_Task_Action),
        //            typeof(SYSHelper.OI_SYS_MAXID),

        //            typeof(TN_Count_Plan),
        //            typeof(TN_Count_Order),
        //            typeof(TN_Count_CG_Detail),
        //            typeof(TN_Count_Diff),
        //        };

        //        using (var tran = db.Ado.UseTran()) {
        //            if (cover) {
        //                // 删除所有表（按依赖关系倒序）
        //                var tables = db.DbMaintenance.GetTableInfoList();
        //                foreach (var table in tables.OrderByDescending(t => t.Name)) {
        //                    db.DbMaintenance.DropTable(table.Name);
        //                }

        //                // 创建新表
        //                db.CodeFirst.InitTables(entityTypes);

        //                //db.CodeFirst.BackupTable().InitTables(entityTypes);
        //            }
        //            else {
        //                db.CodeFirst.InitTables(entityTypes);
        //            }

        //            tran.CommitTran();
        //        }

        //    }
        //    catch (Exception ex) {
        //        LogHelper.Info($"发生了异常");
        //        return "初始化数据库错误" + ex.Message;
        //    }

        //    return "成功";
        //}

        /// <summary>
        /// DEBUG：插入货位、容器、货品信息
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Route("InsertLocCntrCg")]
        public string InsertLocCntrCg(LocCntrCg locCntrCg) {
            var db = new SqlHelper<object>().GetInstance();

            try {
                using (var tran = db.UseTran()) {
                    LogHelper.Info("LogCntrCg：" + JsonConvert.SerializeObject(locCntrCg));
                    if (string.IsNullOrEmpty(locCntrCg.LocCode)) {
                        return "参数非法";
                    }

                    var loc = db.Queryable<TN_Location>().First(a => a.S_CODE == locCntrCg.LocCode);
                    if (loc == null) {
                        var newLoc = new TN_Location {
                            S_CODE = locCntrCg.LocCode,
                            S_AREA_CODE = locCntrCg.LocArea ?? ""
                        };

                        if (db.Insertable<TN_Location>(newLoc).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            LogHelper.Info($"插入位置{locCntrCg.LocCode}失败");
                            return "插入失败";
                        }

                        loc = newLoc;
                    }

                    //if (loc.N_CURRENT_NUM == 0) {
                    //    loc.N_CURRENT_NUM = 1;
                    //    if (db.Updateable<TN_Location>(loc).UpdateColumns(
                    //        it => new { it.N_CURRENT_NUM, it.T_MODIFY }).ExecuteCommand() <= 0) {
                    //        tran.RollbackTran();
                    //        LogHelper.Info($"修改位置{locCntrCg.LocCode}失败");
                    //        continue;
                    //    }
                    //}

                    if (string.IsNullOrEmpty(locCntrCg.CntrCode)) {
                        tran.CommitTran();
                        LogHelper.Info("容器号为空，不再读取后面的数据");
                        return "容器号为空，不再读取后面的数据";
                    }

                    var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == locCntrCg.LocCode
                        && a.S_CNTR_CODE == locCntrCg.CntrCode);

                    if (locCntrRel == null) {
                        var newLocCntrRel = new TN_Loc_Container {
                            S_LOC_CODE = locCntrCg.LocCode,
                            S_CNTR_CODE = locCntrCg.CntrCode
                        };

                        loc.N_CURRENT_NUM = 1;

                        if (db.Insertable<TN_Loc_Container>(newLocCntrRel).ExecuteCommand() <= 0
                            && db.Updateable<TN_Location>(loc).UpdateColumns(c => c.N_CURRENT_NUM).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            LogHelper.Info($"插入位置托盘关系{locCntrCg.LocCode}-{locCntrCg.CntrCode}失败");
                            return "插入失败";
                        }
                    }

                    if (string.IsNullOrEmpty(locCntrCg.ItemCode)) {
                        tran.CommitTran();
                        LogHelper.Info("物料号为空，不再读取后面的数据");
                        return "物料号为空，不再读取后面的数据";
                    }

                    var cgDetail = db.Queryable<TN_CG_Detail>().First(a => a.S_CNTR_CODE == locCntrCg.CntrCode
                        && a.S_ITEM_CODE == locCntrCg.ItemCode);
                    if (cgDetail == null) {
                        var locList = new List<TN_CG_Detail>();
                        locList.Add(new TN_CG_Detail { S_CNTR_CODE = locCntrCg.CntrCode, S_ITEM_CODE = locCntrCg.ItemCode, S_BATCH_NO = locCntrCg.BatchNo ?? "" });
                        if (db.Insertable<TN_CG_Detail>(locList).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            LogHelper.Info($"插入托盘物料关系{locCntrCg.CntrCode}-{locCntrCg}失败");
                            return "插入失败";
                        }
                    }
                    tran.CommitTran();
                }

                return "插入数据成功";

            }
            catch (Exception ex) {
                return $"{ex.Message}";
            }
        }

        /// <summary>
        /// DEBUG：根据任务号设置物料重量
        /// </summary>

 api/ErpController.cs

@@ -25,13 +25,8 @@
        public IHttpActionResult InboundDataSync(InboundDataSyncInfo model) {
            LogHelper.Info("触发API：入库数据同步" + JsonConvert.SerializeObject(model), "API");

            //var headers = Request.Headers; // 暂不考虑对请求HTTP进行校验，默认发来的请求格式都正确

            //return new ErpResult { errCode = 1, errMsg = "测试" };
            //return CreateSuccessResponse(new ErpResult { errCode = 1, errMsg = "测试"});

            //var headers = Request.Headers;
            //return ProcessInboundData(headers, model);
            //return ProcessInboundData(headers, model); // 如果要求对HTTP报文字段校验，使用这行代码

            //return ApiHelper.InboundDataSync(model);
            return NormalProcessInboundData(model); // 暂时使用原本的逻辑
@@ -48,7 +43,7 @@
            LogHelper.Info("触发API：出库发料同步" + JsonConvert.SerializeObject(model), "API");

            //var headers = Request.Headers;
            //return ProcessOutboundData(headers, model);
            //return ProcessOutboundData(headers, model); // 如果要求对HTTP报文字段校验，使用这行代码

            //return ApiHelper.OutboundDataSync(model);
            return NormalProcessOutboundData(model); // 暂时使用原本的逻辑

 core/Monitor.cs

@@ -15,131 +15,131 @@
    /// </summary>
    public class Monitor
    {
        public static void CheckCountOrder() {
            var taskName = TaskName.盘点理货出库;
            var db = new SqlHelper<object>().GetInstance();
            var info = "";
        //public static void CheckCountOrder() {
        //    var taskName = TaskName.盘点理货出库;
        //    var db = new SqlHelper<object>().GetInstance();
        //    var info = "";

            try {
                var orderList = db.Queryable<TN_Count_Order>()
                    .Where(c => c.N_B_STATE == 1)
                    .OrderBy(c => c.T_CREATE, SqlSugar.OrderByType.Asc)
                    .ToList();
        //    try {
        //        var orderList = db.Queryable<TN_Count_Order>()
        //            .Where(c => c.N_B_STATE == 1)
        //            .OrderBy(c => c.T_CREATE, SqlSugar.OrderByType.Asc)
        //            .ToList();

                if (orderList.Count == 0) {
                    LogHelper.Info($"轮询--{taskName}--暂无待执行的{taskName}单");
                    return;
                }
        //        if (orderList.Count == 0) {
        //            LogHelper.Info($"轮询--{taskName}--暂无待执行的{taskName}单");
        //            return;
        //        }

                var detailList = new List<TN_Count_CG_Detail>();
                foreach (var order in orderList) {
                    var doingCount = db.Queryable<TN_Count_CG_Detail>()
                        .Count(d => d.S_COUNT_NO == order.S_COUNT_NO && d.N_B_STATE >= 2); // 执行中
                    var allCount = db.Queryable<TN_Count_CG_Detail>()
                        .Count(d => d.S_COUNT_NO == order.S_COUNT_NO);
                    LogHelper.Info($"轮询--{taskName}--统计{taskName}单'{order.S_COUNT_NO}'任务已下发：{doingCount}/{allCount}");
        //        var detailList = new List<TN_Count_CG_Detail>();
        //        foreach (var order in orderList) {
        //            var doingCount = db.Queryable<TN_Count_CG_Detail>()
        //                .Count(d => d.S_COUNT_NO == order.S_COUNT_NO && d.N_B_STATE >= 2); // 执行中
        //            var allCount = db.Queryable<TN_Count_CG_Detail>()
        //                .Count(d => d.S_COUNT_NO == order.S_COUNT_NO);
        //            LogHelper.Info($"轮询--{taskName}--统计{taskName}单'{order.S_COUNT_NO}'任务已下发：{doingCount}/{allCount}");

                    if (doingCount == allCount) {
                        order.N_B_STATE = 2; // 所有任务都已执行
                        db.Updateable<TN_Count_Order>(order).UpdateColumns(it => new { it.N_B_STATE }).ExecuteCommand();
                        continue;
                    }

                    var countCgDetailList = db.Queryable<TN_Count_CG_Detail>()
                        .Where(a => a.S_COUNT_NO == order.S_COUNT_NO && a.N_B_STATE == 1) // 已下发
                        .ToList();

                    if (countCgDetailList.Count == 0) {
                        LogHelper.Info($"轮询--{taskName}--{taskName}单明细状态异常");
                        continue;
                    }

                    detailList.AddRange(countCgDetailList);
                }

                if (detailList.Count == 0) {
                    return;
                }

                foreach (var detail in detailList) {
                    var startLoc = db.Queryable<TN_Location>()
                        .LeftJoin<TN_Loc_Container>((l, c) => l.S_CODE == c.S_LOC_CODE)
                        .Where((l, c) => c.S_CNTR_CODE == detail.S_CNTR_CODE)
                        .First();

                    if (startLoc == null) {
                        LogHelper.Info($"轮询--{taskName}：没有找到合适的起点货位！");
                        continue;
                    }

                    var endLoc = db.Queryable<TN_Location>()
                        .Where(a => Settings.Areas[0].Contains(a.S_AREA_CODE))
                        .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y")
                        .Where(a => a.N_CURRENT_NUM == 0).First();

                    if (endLoc == null) {
                        LogHelper.Info($"轮询--{taskName}：没有找到合适的终点货位！单号为 '{detail.S_COUNT_NO}'");
                        continue;
                    }

                    detail.N_B_STATE = 2;

                    var cntId = detail.S_CNTR_CODE;
                    var task = WCSHelper.BuildTask(startLoc, endLoc, cntId, taskName);

                    LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
                    LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁

                    using (var tran = db.Ado.UseTran()) {
                        if (db.Updateable<TN_Count_CG_Detail>(detail).UpdateColumns(it => it.N_B_STATE).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            LogHelper.Info($"轮询--{taskName}--修改明细表状态为完成失败！");
                        }

                        if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
                            it.N_LOCK_STATE,
                            it.S_LOCK_STATE,
                            it.S_LOCK_OP,
                            it.T_MODIFY
                        }).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            info = $"生成任务'{taskName}'失败，容器号{cntId}，起点{startLoc.S_CODE}，终点货位{endLoc.S_CODE}";
                            LogHelper.Info(info);
                            continue;
                        }

                        if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
                            it.N_LOCK_STATE,
                            it.S_LOCK_STATE,
                            it.S_LOCK_OP,
                            it.T_MODIFY
                        }).ExecuteCommand() <= 0) {

                            tran.RollbackTran();
                            info = $"生成'{taskName}'失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}";
                            LogHelper.Info(info);
                            continue;
                        }

                        if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            info = $"生成 {taskName} 失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}";
                            LogHelper.Info(info);
                            continue;
                        }

                        tran.CommitTran();
                        info = $"生成 {taskName} 成功，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}";
                        LogHelper.Info(info);
        //            if (doingCount == allCount) {
        //                order.N_B_STATE = 2; // 所有任务都已执行
        //                db.Updateable<TN_Count_Order>(order).UpdateColumns(it => new { it.N_B_STATE }).ExecuteCommand();
                        //continue;
                    }
                }
            }
            catch (Exception ex) {
                info = $"发生了异常：{ex.Message}";
                LogHelper.Info(info);
            }
        }
        //            }

        //            var countCgDetailList = db.Queryable<TN_Count_CG_Detail>()
        //                .Where(a => a.S_COUNT_NO == order.S_COUNT_NO && a.N_B_STATE == 1) // 已下发
        //                .ToList();

        //            if (countCgDetailList.Count == 0) {
        //                LogHelper.Info($"轮询--{taskName}--{taskName}单明细状态异常");
        //                continue;
        //            }

        //            detailList.AddRange(countCgDetailList);
        //        }

        //        if (detailList.Count == 0) {
        //            return;
        //        }

        //        foreach (var detail in detailList) {
        //            var startLoc = db.Queryable<TN_Location>()
        //                .LeftJoin<TN_Loc_Container>((l, c) => l.S_CODE == c.S_LOC_CODE)
        //                .Where((l, c) => c.S_CNTR_CODE == detail.S_CNTR_CODE)
        //                .First();

        //            if (startLoc == null) {
        //                LogHelper.Info($"轮询--{taskName}：没有找到合适的起点货位！");
        //                continue;
        //            }

        //            var endLoc = db.Queryable<TN_Location>()
        //                .Where(a => Settings.Areas[0].Contains(a.S_AREA_CODE))
        //                .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y")
        //                .Where(a => a.N_CURRENT_NUM == 0).First();

        //            if (endLoc == null) {
        //                LogHelper.Info($"轮询--{taskName}：没有找到合适的终点货位！单号为 '{detail.S_COUNT_NO}'");
        //                continue;
        //            }

        //            detail.N_B_STATE = 2;

        //            var cntId = detail.S_CNTR_CODE;
        //            var task = WCSHelper.BuildTask(startLoc, endLoc, cntId, taskName);

        //            LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
        //            LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁

        //            using (var tran = db.Ado.UseTran()) {
        //                if (db.Updateable<TN_Count_CG_Detail>(detail).UpdateColumns(it => it.N_B_STATE).ExecuteCommand() <= 0) {
        //                    tran.RollbackTran();
        //                    LogHelper.Info($"轮询--{taskName}--修改明细表状态为完成失败！");
        //                }

        //                if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
        //                    it.N_LOCK_STATE,
        //                    it.S_LOCK_STATE,
        //                    it.S_LOCK_OP,
        //                    it.T_MODIFY
        //                }).ExecuteCommand() <= 0) {
        //                    tran.RollbackTran();
        //                    info = $"生成任务'{taskName}'失败，容器号{cntId}，起点{startLoc.S_CODE}，终点货位{endLoc.S_CODE}";
        //                    LogHelper.Info(info);
        //                    continue;
        //                }

        //                if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
        //                    it.N_LOCK_STATE,
        //                    it.S_LOCK_STATE,
        //                    it.S_LOCK_OP,
        //                    it.T_MODIFY
        //                }).ExecuteCommand() <= 0) {

        //                    tran.RollbackTran();
        //                    info = $"生成'{taskName}'失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}";
        //                    LogHelper.Info(info);
        //                    continue;
        //                }

        //                if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
        //                    tran.RollbackTran();
        //                    info = $"生成 {taskName} 失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}";
        //                    LogHelper.Info(info);
        //                    continue;
        //                }

        //                tran.CommitTran();
        //                info = $"生成 {taskName} 成功，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}";
        //                LogHelper.Info(info);
        //                //continue;
        //            }
        //        }
        //    }
        //    catch (Exception ex) {
        //        info = $"发生了异常：{ex.Message}";
        //        LogHelper.Info(info);
        //    }
        //}
    }

}

 core/WCSCore.cs

@@ -19,7 +19,7 @@
        public static ReturnResult OperateAgvTaskStatus(AgvTaskState model) {
            var result = new ReturnResult();
            try {
                if (model.state > 0 && model.state < 1000) {
                if (model.state > 0) {
                    // AGV 执行任务的逻辑处理
                    if (!AgvTaskProcessOk(model)) {
                        // 执行不OK，说明没有找到任务
@@ -347,37 +347,10 @@
            }
        }

        // DOC 4.    站台申请安全交互 RCS->WMS
        public static ReturnResult SafetyInteraction(SafetyInteractionInfo model) {
            var gzResult = new ReturnResult();
            //var db = new SqlHelper<object>().GetInstance();
            //ModbusHelper.Relink();

            //var productionLineInfo = Settings.ProductionLines[0];
            //var prodLineDevice = new ProductionLineDevice(productionLineInfo.PlcIp, productionLineInfo.PlcPort);
            //if (!prodLineDevice.LoadDeviceStateOk()) {
            //    LogHelper.Info("加载设备信息失败");
            //}

            //var tn_task = db.Queryable<TN_Task>().First(a => a.S_CODE == model.task_no);
            //if (tn_task == null) {
            //    LogHelper.Info($"任务号 '{model.task_no}' 不存在");
            //}

            //if (prodLineDevice.SystemState == 1
            //    && prodLineDevice.FullOffline == 1 && tn_task.S_TYPE == "成品胶下线-托盘(WMS)") {
            //    if (!prodLineDevice.SetAgvPicking(1)) {
            //        LogHelper.Info("写入输送线 PLC 失败");
            //    }
            //}

            //if (prodLineDevice.SystemState == 1
            //    && prodLineDevice.AllowAgvPlacePallet == 1 && tn_task.S_TYPE == "空托盘上线(WMS)") {
            //    if (!prodLineDevice.SetAgvPlacingPallet(1)) {
            //        LogHelper.Info("写入输送线 PLC 失败");
            //    }
            //}

            //LogHelper.Info(JsonConvert.SerializeObject(prodLineDevice, Formatting.Indented));
            // 目前该项目没有站台安全交互的功能
            return gzResult;
        }
    }

 dispatch/GZRobot.cs

@@ -27,6 +27,7 @@
            var dataResult = JsonConvert.DeserializeObject<gzResult<IOStatesInfoResult>>(result);
        }

        // DOC 1.    创建订单 WMS->RCS
        public static int CreateOrder(string taskNo, int priority, string param, string ts = "churuku", string created_user = "hanhe") {
            LogHelper.Info($"CreateOrder参数信息:taskNo:{taskNo},priority:{priority},param:{param},ts:{ts}，created_user：{created_user}", "API");
            var msg = "";
@@ -76,6 +77,7 @@
            return result;
        }

        // DOC 2.    取消订单 WMS->RCS
        public static bool CancelGZOrder(int orderId) {
            bool result = false;
            string msg = "";
@@ -86,12 +88,21 @@
            msg = $"[guozi-CancelOrder] request={requests};response={response}";
            if (response != "") {
                var dataResult = JsonConvert.DeserializeObject<CancelGZOrderResult>(response);
                if (dataResult.code == 0) {
                    msg = "[guozi-CancelOrder]取消订单成功";
                    Console.WriteLine(msg);
                // 原代码版本
                //if (dataResult.code == 0) {
                //    msg = "[guozi-CancelOrder]取消订单成功";
                //    Console.WriteLine(msg);
                //    result = true;
                //    return result;
                //}

                // 尊重文档的版本
                if (dataResult.msg == "success") { // 目前只取消一个任务，成功无需再检查success_list和error_list
                    Console.WriteLine("[guozi-CancelOrder]取消订单成功");
                    result = true;
                    return result;
                }

            }
            else {
                msg = "[guozi-CancelOrder]取消订单失败";
@@ -100,7 +111,7 @@
            return result;
        }


        // DOC 3.    订单状态推送 RCS->WMS
        /// <summary>
        /// 订单状态反馈
        /// </summary>
@@ -193,6 +204,7 @@
            return result;
        }

        // DOC 6.    交互表查询
        /// <summary>
        /// 获取交互信息
        /// </summary>
@@ -228,6 +240,7 @@
            return list;
        }

        // DOC 备用
        public static bool UpdateInteractInfo(UpdateInteractInfo interactInfo) {
            string msg = "";
            var result = false;
@@ -245,6 +258,7 @@
            return result;
        }

        // DOC 5.    称重信息查询
        public static List<CustomData> CustomBuf() {
            var res = new List<CustomData>();
            string msg = "";

 process/TaskProcess.cs

@@ -6,6 +6,7 @@
using System.Linq;
using HH.WCS.Mobox3.AnGang.models;
using System;
using HH.WCS.Mobox3.AnGang.util;

namespace HH.WCS.Mobox3.AnGang.process {
    internal class TaskProcess {
@@ -106,13 +107,19 @@
        /// </summary>
        /// <param name="mst"></param>
        internal static bool SendTask(TN_Task mst) {

            var db = new SqlHelper<object>().GetInstance();
            var result = false;
            var start = "0"; var end = "0";
            var taskType = mst.S_TYPE.Trim();
            if (mst.N_B_STATE == 0) {
                // 原代码版本
                //var code = GZRobot.CreateOrder(mst.S_CODE, mst.N_PRIORITY, JsonConvert.SerializeObject(new { src = mst.S_START_LOC, dst = mst.S_END_LOC }), "p2p");
                // 尊重文档的版本（暂不考虑修改，因为没有终点站点，不合理）
                //var startSite = LocationHelper.GetAgvSite(mst.S_START_LOC);
                //var endSite = LocationHelper.GetAgvSite(mst.S_END_LOC);

                var code = GZRobot.CreateOrder(mst.S_CODE, mst.N_PRIORITY, JsonConvert.SerializeObject(new { src = mst.S_START_LOC, dst = mst.S_END_LOC }), "p2p");
                var code = GZRobot.CreateOrder(mst.S_CODE, mst.N_PRIORITY, JsonConvert.SerializeObject(new { src = mst.S_START_LOC, dst = mst.S_END_LOC }), "p2pdst", "pgapi");

                if (code > 0) {
                    //更新任务状态
                    mst.N_B_STATE = 1;