优化配置文件和部分日志打印信息

kazelee

2025-06-27 d20ce230b49932d39ee4ce25e39fd78368c3b28a

优化配置文件和部分日志打印信息

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/1a495659-e37c-434f-8b88-6132140fefe1.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/1b470183-023c-416d-bb96-68ba4438601c.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/334f7960-776b-4009-822a-0655d70b3d13.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/41345d82-13c1-4c64-a4e0-a6fa1d398c60.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/464eaeb0-6a8d-451a-9aba-ddc122b33d68.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/582aed91-b4b2-4db8-856f-14042adcf757.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/9ac976c0-07a0-401d-88dc-3e2e5fd17dbc.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/d8091da7-1660-402d-a5cf-dce290dff156.vsidx

Binary files differ

 HH.WCS.Mobox3.DSZSH.csproj

@@ -272,6 +272,7 @@
    <Compile Include="dispatch\HostToAGV.cs" />
    <Compile Include="util\LogHelper.cs" />
    <Compile Include="wms\ContainerHelper.cs" />
    <Compile Include="wms\InfoBuilder.cs" />
    <Compile Include="wms\LocationHelper.cs" />
    <Compile Include="wms\SYSHelper.cs" />
    <Compile Include="Program.cs" />

 Program.cs

@@ -158,7 +158,5 @@
                return task;
            }
        }

        
    }
}

 api/AgvController.cs

@@ -45,8 +45,6 @@
            return WCSCore.SafetyInteraction(model);
        }



        // 备用：Request 请求授权 ---------------------------------------------

        // 模拟存储的AppKey和AppSecret（实际应存储在数据库或配置中）

 api/ApiHelper.cs

@@ -16,7 +16,7 @@
namespace HH.WCS.Mobox3.DSZSH.api {
    public class ApiHelper {
        /// <summary>
        /// 好运箱-满箱下线入库(PDA)
        /// 满箱下线入库
        /// </summary>
        /// <remarks>
        /// 人工：产线==>满箱操作区<br/>
@@ -29,9 +29,12 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.H好运箱_满箱下线入库;
            const string startAreaName = AreaName.M满箱操作区;
            const string endAreaName = AreaName.M满箱货架区;
            var taskInfo = Settings.GetTaskInfo(ETask.M满箱下线入库);
            var taskName = taskInfo.TaskName;
            var startAreas = taskInfo.StartAreas;
            var endAreas = taskInfo.EndAreas;

            var log = $"API：{taskName}：";

            try {
                if (model.Num <= 0) {
@@ -40,10 +43,7 @@
                    return NewSimpleResult(400, info);
                }

                var cgDetail = db.Queryable<TN_CG_Detail>()
                    .Where(d => d.S_ITEM_CODE == model.ItemCode && d.S_BATCH_NO == model.BatchNo)
                    .Where(d => d.N_ITEM_STATE == 1 && d.S_ITEM_STATE == "待检")
                    .First(); // TODO model 中 数量、规格是否也参与比对 待后续要求
                var cgDetail = db.Queryable<TN_CG_Detail>().Where(d => d.S_ITEM_CODE == model.ItemCode && d.S_BATCH_NO == model.BatchNo && d.N_ITEM_STATE == 1 && d.S_ITEM_STATE == "待检").First(); // TODO model 中 数量、规格是否也参与比对 待后续要求

                if (cgDetail == null) {
                    info = $"PDA扫码物料信息与贴标机传递的信息不一致：" + JsonConvert.SerializeObject(model);
@@ -51,18 +51,13 @@
                    return NewSimpleResult(1, info);
                }

                var startLoc = db.Queryable<TN_Location>()
                    .Where(l => l.S_CODE == model.StartLoc)
                    .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.N_CURRENT_NUM == 0) // 绑定前
                    .First();
                var startLoc = LocationHelper.GetLocQuery(db, 0, startAreas, model.StartLoc).First();

                if (startLoc == null) {
                    info = $"在'{startAreaName}'中没有找到起点货位'{model.StartLoc}'，或不满足要求：未上锁、当前容器数量=0";
                    info = $"：没有找到起点货位'{model.StartLoc}'！要求：未上锁、数量=0、货区属于[{string.Join(", ", startAreas)}]";
                    LogHelper.Info(info);
                    return NewSimpleResult(2, info);
                } 
                }

                startLoc.N_CURRENT_NUM = 1; // 绑定后

@@ -72,51 +67,36 @@
                    S_CNTR_TYPE = "好运箱",
                };

                var endLoc = db.Queryable<TN_Location>()
                    .Where(l => Settings.AreaMap[endAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.N_CURRENT_NUM == 0)
                    .OrderBy(l => l.N_LAYER) // 按货架最低排序
                    .First();// TODO 满箱入库算法待优化

                var endLoc = LocationHelper.GetLocQuery(db, 0, endAreas).OrderBy(l => new { l.N_LAYER }).First();
                
                if (endLoc == null) {
                    info = $"在'{endAreaName}'中没有找到合适的终点货位，需要满足：未上锁、当前容器数量=0";
                    info = $"没有找到合适的终点货位，需要满足：未上锁、当前容器数量=0";
                    LogHelper.Info(info);
                    return NewSimpleResult(3, info);
                } 
                }

                LocationHelper.LockStartLoc(ref startLoc);
                LocationHelper.LockEndLoc(ref endLoc);

                var cntId = locCntrRel.S_CNTR_CODE; // 容器号
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntId, taskName);

                using (var tran = db.Ado.UseTran()) {
                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        info = $"插入【货位容器绑定】表失败：" + JsonConvert.SerializeObject(locCntrRel);
                        info = $"插入货位容器绑定表失败：" + JsonConvert.SerializeObject(locCntrRel);
                        tran.RollbackTran();
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE,
                        it.S_LOCK_STATE,
                        it.S_LOCK_OP,
                        it.T_MODIFY,
                        it.N_CURRENT_NUM, // 起点货位绑定后，将货位状态更新
                    }).ExecuteCommand() <= 0) {
                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY, it.N_CURRENT_NUM, }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败：更新起点货位{startLoc.S_CODE}锁状态失败";
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    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) {
                    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}'失败：更新终点货位{endLoc.S_CODE}锁状态失败";
                        LogHelper.Info(info);
@@ -144,7 +124,7 @@
        }

        /// <summary>
        /// 托盘-空托入库(PDA)
        /// 空托入库
        /// </summary>
        /// <remarks>
        /// 人工将空托盘通过接驳位入库，需要新绑定容器货位<br/>
@@ -156,21 +136,22 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.T托盘_空托入库;
            const string startAreaName = AreaName.K空托入库接驳区;
            const string endAreaName = AreaName.K空托存放区;
            const string cntrType = "托盘";
            var taskInfo = Settings.GetTaskInfo(ETask.K空托入库);
            var taskName = taskInfo.TaskName;
            var startAreas = taskInfo.StartAreas;
            var endAreas = taskInfo.EndAreas;
            var cntrType = "托盘";

            try {
                var startLoc = db.Queryable<TN_Location>()
                    .Where(l => l.S_CODE == model.StartLoc)
                    .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => startAreas.Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.N_CURRENT_NUM == 0)
                    .First();

                if (startLoc == null) {
                    info = $"在'{startAreaName}'中没有找到起点货位'{model.StartLoc}'，或不具备起点取货要求：未上锁、绑定前无货物";
                    info = $"没有找到起点货位'{model.StartLoc}'，或不具备起点取货要求：未上锁、绑定前无货物";
                    LogHelper.Info(info);
                    return NewSimpleResult(1, info);
                }
@@ -221,14 +202,14 @@
                startLoc.N_CURRENT_NUM = 1; // 绑定后

                var endLoc = db.Queryable<TN_Location>()
                    .Where(l => Settings.AreaMap[endAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => startAreas.Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.N_CURRENT_NUM == 0)
                    .OrderBy(l => new { l.N_LAYER, l.N_ROW, l.N_COL }) // TODO 暂定选择最低层按区位顺序入库，后面待修改
                    .First();

                if (endLoc == null) {
                    info = $"在【{endAreaName}】中没有找到合适的【终点货位】，需要满足：未上锁、无货物";
                    info = $"没有找到合适的终点货位！需要：未上锁、无货物";
                    LogHelper.Info(info);
                    return NewSimpleResult(4, info);
                }
@@ -239,59 +220,42 @@
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntId, taskName);

                using (var tran = db.Ado.UseTran()) {
                    if (cgDetailOld != null) {
                        if (db.Deleteable<TN_CG_Detail>(cgDetailOld).ExecuteCommand() <= 0) {
                            info = $"删除【旧物料信息】失败：" + JsonConvert.SerializeObject(cgDetailOld);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }

                    if (locCntrRelOld != null) {
                        if (db.Deleteable<TN_Loc_Container>(locCntrRelOld).ExecuteCommand() <= 0) {
                            info = $"删除【旧货位容器关系】失败：" + JsonConvert.SerializeObject(locCntrRelOld);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }

                    if (locOld != null) {
                        if (db.Updateable<TN_Location>(locOld).UpdateColumns(l => new { l.N_CURRENT_NUM, l.T_MODIFY }).ExecuteCommand() <= 0) {
                            info = $"更新旧货位【容器数量】失败：" + JsonConvert.SerializeObject(locOld);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        info = $"插入【货位容器关系】失败：" + JsonConvert.SerializeObject(locCntrRel);
                    if (cgDetailOld != null && db.Deleteable<TN_CG_Detail>(cgDetailOld).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"删除【旧物料信息】失败：" + JsonConvert.SerializeObject(cgDetailOld);
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE,
                        it.S_LOCK_STATE,
                        it.S_LOCK_OP,
                        it.T_MODIFY,
                        it.N_CURRENT_NUM
                    }).ExecuteCommand() <= 0) {
                    if (locCntrRelOld != null && db.Deleteable<TN_Loc_Container>(locCntrRelOld).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"删除【旧货位容器关系】失败：" + JsonConvert.SerializeObject(locCntrRelOld);
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    if (locOld != null && db.Updateable<TN_Location>(locOld).UpdateColumns(l => new { l.N_CURRENT_NUM, l.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"更新旧货位【容器数量】失败：" + JsonConvert.SerializeObject(locOld);
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"插入【货位容器关系】失败：" + JsonConvert.SerializeObject(locCntrRel);
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY, it.N_CURRENT_NUM }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败：更新起点货位'{startLoc.S_CODE}'锁状态失败";
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    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) {
                    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}'失败：更新终点货位'{endLoc.S_CODE}'锁状态失败";
                        LogHelper.Info(info);
@@ -319,7 +283,7 @@
        }

        /// <summary>
        /// 好运箱-空箱入库(PDA)
        /// 空箱入库(好运箱)
        /// </summary>
        /// <remarks>
        /// 人工：空箱==搬运==>入库接驳位，需要新绑定容器货位<br/>
@@ -330,21 +294,22 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.H好运箱_空箱入库;
            const string startAreaName = AreaName.K空箱入库接驳区;
            const string endAreaName = AreaName.K空箱货架区;
            var taskInfo = Settings.GetTaskInfo(ETask.K空箱入库);
            var taskName = taskInfo.TaskName;
            var startAreas = taskInfo.StartAreas;
            var endAreas = taskInfo.EndAreas;
            const string cntrType = "好运箱";

            try {
                var startLoc = db.Queryable<TN_Location>()
                    .Where(l => l.S_CODE == model.StartLoc)
                    .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => startAreas.Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.N_CURRENT_NUM == 0) // 绑定前
                    .First();

                if (startLoc == null) {
                    info = $"在'{startAreaName}'中没有找到起点货位'{model.StartLoc}'，或不满足要求：未上锁、当前容器数量=0";
                    info = $"没有找到起点货位'{model.StartLoc}'，或不满足要求：未上锁、当前容器数量=0";
                    LogHelper.Info(info);
                    return NewSimpleResult(2, info);
                }
@@ -392,14 +357,14 @@
                startLoc.N_CURRENT_NUM = 1; // 绑定后

                var endLoc = db.Queryable<TN_Location>()
                    .Where(l => Settings.AreaMap[endAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => endAreas.Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.N_CURRENT_NUM == 0)
                    .OrderBy(l => new { l.N_LAYER }) // TODO 暂定选择最低层顺序入库，后面待修改
                    .First();

                if (endLoc == null) {
                    info = $"在'{endAreaName}'中没有找到合适的终点货位，需要满足：未上锁、无货物";
                    info = $"没有找到合适的终点货位！需要：未上锁、无货物";
                    LogHelper.Info(info);
                    return NewSimpleResult(4, info);
                }
@@ -412,59 +377,42 @@

                using (var tran = db.Ado.UseTran()) {
                    // 存在旧【物料明细】表时，删除旧表
                    if (cgDetailOld != null) {
                        if (db.Deleteable<TN_CG_Detail>(cgDetailOld).ExecuteCommand() <= 0) {
                            info = $"删除【旧物料信息】失败：" + JsonConvert.SerializeObject(cgDetailOld);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    if (cgDetailOld != null && db.Deleteable<TN_CG_Detail>(cgDetailOld).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"删除【旧物料信息】失败：" + JsonConvert.SerializeObject(cgDetailOld);
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }
                    // 存在旧【货位容器绑定】表时，删除旧表
                    if (locCntrRelOld != null) {
                        if (db.Deleteable<TN_Loc_Container>(locCntrRelOld).ExecuteCommand() <= 0) {
                            info = $"删除【旧货位容器关系】失败：" + JsonConvert.SerializeObject(locCntrRelOld);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }

                    if (locOld != null) {
                        if (db.Updateable<TN_Location>(locOld).UpdateColumns(l => l.N_CURRENT_NUM).ExecuteCommand() <= 0) {
                            info = $"更新旧货位【容器数量】失败：" + JsonConvert.SerializeObject(locOld);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        info = $"插入【货位容器关系】失败：" + JsonConvert.SerializeObject(locCntrRel);
                    if (locCntrRelOld != null && db.Deleteable<TN_Loc_Container>(locCntrRelOld).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"删除【旧货位容器关系】失败：" + JsonConvert.SerializeObject(locCntrRelOld);
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE,
                        it.S_LOCK_STATE,
                        it.S_LOCK_OP,
                        it.T_MODIFY,
                        it.N_CURRENT_NUM
                    }).ExecuteCommand() <= 0) {
                    if (locOld != null && db.Updateable<TN_Location>(locOld).UpdateColumns(l => l.N_CURRENT_NUM).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"更新旧货位【容器数量】失败：" + JsonConvert.SerializeObject(locOld);
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"插入【货位容器关系】失败：" + JsonConvert.SerializeObject(locCntrRel);
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY, it.N_CURRENT_NUM }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败：更新起点货位'{startLoc.S_CODE}'锁状态失败";
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    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) {
                    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}'失败：更新终点货位'{endLoc.S_CODE}'锁状态失败";
                        LogHelper.Info(info);
@@ -492,7 +440,7 @@
        }

        /// <summary>
        /// 托盘-空托上线(PDA)
        /// 空托上线出库
        /// </summary>
        /// <remarks>
        /// 人工根据当前生产物料所需的容器类型，呼叫AGV从空容器货架中叫一个符合要求的托盘
@@ -503,9 +451,10 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.T托盘_空托上线;
            const string startAreaName = AreaName.K空托存放区;
            const string endAreaName = AreaName.B包装区;
            var taskInfo = Settings.GetTaskInfo(ETask.K空托上线出库);
            var taskName = taskInfo.TaskName;
            var startAreas = taskInfo.StartAreas;
            var endAreas = taskInfo.EndAreas;
            const string cntrType = "托盘";

            try {
@@ -544,25 +493,25 @@
                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 == model.CntId)
                    .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => startAreas.Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.N_CURRENT_NUM == 1)
                    .First();

                if (startLoc == null) {
                    info = $"在'{startAreaName}'中，找不到适用于{model.ItemCode}物料、且编码为{model.CntId}的空托盘";
                    info = $"找不到适用于{model.ItemCode}物料、且编码为{model.CntId}的空托盘";
                    LogHelper.Info(info);
                    return NewSimpleResult(3, info);
                }

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

                if (endLoc == null) {
                    info = $"在'{endAreaName}'中，找不到合适的【终点货位】，需要满足：未上锁、当前容器数量=0";
                    info = $"找不到合适的终点货位，需要满足：未上锁、当前容器数量=0";
                    LogHelper.Info(info);
                    return NewSimpleResult(4, info);
                }
@@ -587,24 +536,14 @@
                        }
                    }

                    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) {
                    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}'失败：更新起点货位'{startLoc.S_CODE}'锁状态失败";
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    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) {
                    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}'失败：更新终点货位'{endLoc.S_CODE}'锁状态失败";
                        LogHelper.Info(info);
@@ -632,7 +571,7 @@
        }

        /// <summary>
        /// 好运箱-空箱上线(PDA)
        /// 空箱上线出库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
@@ -640,9 +579,10 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.H好运箱_空箱上线;
            const string startAreaName = AreaName.K空箱货架区;
            const string endAreaName = AreaName.K空箱操作区;
            var taskInfo = Settings.GetTaskInfo(ETask.K空箱上线出库);
            var taskName = taskInfo.TaskName;
            var startAreas = taskInfo.StartAreas;
            var endAreas = taskInfo.EndAreas;
            const string cntrType = "好运箱";

            try {
@@ -664,25 +604,25 @@
                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 == model.CntId && c.S_CNTR_TYPE == "好运箱")
                    .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => startAreas.Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.N_CURRENT_NUM == 1)
                    .First();

                if (startLoc == null) {
                    info = $"在'{startAreaName}'中，找不到存放容器编码={model.CntId}的空好运箱的【起点货位】，或不满足：未上锁、当前数量=1";
                    info = $"没有找到起点货位'{model.CntId}的空好运箱的【起点货位】，或不满足：未上锁、当前数量=1";
                    LogHelper.Info(info);
                    return NewSimpleResult(2, info);
                }

                var endLoc = db.Queryable<TN_Location>()
                    .Where(l => Settings.AreaMap[endAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => endAreas.Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y") // 筛选：未上锁
                    .Where(l => l.N_CURRENT_NUM == 0)
                    .First();

                if (endLoc == null) {
                    info = $"在'{endAreaName}'中，找不到合适的【终点货位】，需要满足：未上锁、当前数量=0";
                    info = $"没有找到合适的终点货位！需要：未上锁、无货物";
                    LogHelper.Info(info);
                    return NewSimpleResult(4, info);
                }
@@ -738,9 +678,8 @@
            }
        }

        
        /// <summary>
        /// 抽检-合格回库(PDA)
        /// 抽检合格回库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
@@ -748,9 +687,10 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.C抽检_合格回库;
            const string startAreaName = AreaName.C抽检区;
            var endAreaName = "";
            var taskInfo = Settings.GetTaskInfo(ETask.C抽检合格回库);
            var taskName = taskInfo.TaskName;
            var startAreas = taskInfo.StartAreas;
            var endAreas = taskInfo.EndAreas;

            try {
                var cgDetail = db.Queryable<TN_CG_Detail>()
@@ -777,38 +717,30 @@
                    .Where(l => l.S_CODE == locCntrRel.S_LOC_CODE)
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y") // 筛选：未上锁
                    .Where(l => l.N_CURRENT_NUM == 1)
                    .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE)) // 起点货区符合任务要求
                    .Where(l => startAreas.Contains(l.S_AREA_CODE)) // 起点货区符合任务要求
                    .First();

                if (startLoc == null) {
                    info = $"在'{startAreaName}'中没有找到容器{model.CntrCode}的起点货位，或不具备取货要求：未上锁、有货物";
                    info = $"没有找到容器{model.CntrCode}的起点货位，或不具备取货要求：未上锁、有货物";
                    LogHelper.Info(info);
                    return NewSimpleResult(4, info);
                }

                TN_Location endLoc = null;
                if (locCntrRel.S_CNTR_TYPE == "托盘") {
                    endAreaName = AreaName.M满托货架区;
                    endLoc = db.Queryable<TN_Location>()
                        .Where(l => Settings.AreaMap[endAreaName].Contains(l.S_AREA_CODE))
                        .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y") // 筛选：未上锁
                        .Where(l => l.N_CURRENT_NUM == 0) // 筛选：空货位
                        .First();
                    endAreas = taskInfo.EndAreas_Pallet;
                    endLoc = LocationHelper.GetLocQuery(db, 0, endAreas).First();
                }
                else if (locCntrRel.S_CNTR_TYPE == "好运箱") {
                    endAreaName = AreaName.M满箱货架区;
                    endLoc = db.Queryable<TN_Location>()
                        .Where(l => Settings.AreaMap[endAreaName].Contains(l.S_AREA_CODE))
                        .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y") // 筛选：未上锁
                        .Where(l => l.N_CURRENT_NUM == 0)
                        .First();
                    endAreas = taskInfo.EndAreas_Goodpack;
                    endLoc = LocationHelper.GetLocQuery(db, 0, endAreas).First();
                }
                else {
                    return NewSimpleResult(-1, $"托盘类型{locCntrRel.S_CNTR_TYPE}不合法：托盘号{locCntrRel.S_CNTR_CODE}");
                }

                if (endLoc == null) {
                    info = $"在【{endAreaName}】中没有找到合适的【终点货位】，或不满足要求：未上锁、当前容器数量为 0";
                    info = $"没有找到合适的【终点货位】，或不满足要求：未上锁、当前容器数量为 0";
                    LogHelper.Info(info);
                    return NewSimpleResult(3, info);
                }
@@ -824,32 +756,21 @@
                LocationHelper.LockEndLoc(ref endLoc); // 终点入库锁

                using (var tran = db.Ado.UseTran()) {
                    if (db.Updateable<TN_CG_Detail>(cgDetail).UpdateColumns(it =>
                        new { it.N_ITEM_STATE, it.S_ITEM_STATE, it.T_MODIFY }).ExecuteCommand() <= 0) {
                    if (db.Updateable<TN_CG_Detail>(cgDetail).UpdateColumns(it => new { it.N_ITEM_STATE, it.S_ITEM_STATE, it.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成'{taskName}'失败：修改物料状态为'合格'失败";
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    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) {
                    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}'失败：更新起点货位'{startLoc.S_CODE}'锁状态失败";
                        LogHelper.Info(info);
                        return NewSimpleResult(500, info);
                    }

                    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) {
                    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}'失败：更新终点货位'{endLoc.S_CODE}'锁状态失败";
                        LogHelper.Info(info);
@@ -877,7 +798,7 @@
        }

        /// <summary>
        /// 抽检-不合格移库(PDA)
        /// 抽检不合格移库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
@@ -885,14 +806,14 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.C抽检_不合格移库;
            const string startAreaName = AreaName.C抽检区;
            const string endAreaName = AreaName.C抽检异常区;
            const ETask eTask = ETask.C抽检不合格移库;
            var taskName = Settings.GetTaskInfo(eTask).TaskName;
            var startAreas = Settings.GetTaskInfo(eTask).StartAreas;
            var endAreas = Settings.GetTaskInfo(eTask).EndAreas;

            try {

                if (!Settings.AreaMap[endAreaName].Contains(model.EndArea)) {
                    info = $"输入的终点库区'{model.EndArea}'不属于'{endAreaName}'!";
                if (!startAreas.Contains(model.EndArea)) {
                    info = $"终点库区'{model.EndArea}'不满足条件！需要：货区属于[{string.Join(", ", startAreas)}]";
                    LogHelper.Info(info);
                    return NewSimpleResult(1, info);
                }
@@ -919,13 +840,13 @@

                var startLoc = db.Queryable<TN_Location>()
                    .Where(l => l.S_CODE == locCntrRel.S_LOC_CODE)
                    .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => startAreas.Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y") // 筛选：未上锁
                    .Where(l => l.N_CURRENT_NUM == 1)
                    .First();

                if (startLoc == null) {
                    info = $"在'{startAreaName}'中没有找到起点货位'{locCntrRel.S_LOC_CODE}'，或不满足要求：未上锁、当前容器数量=0";
                    info = $"起点货位' {locCntrRel.S_LOC_CODE} '不满足条件！需要：货区属于[ {string.Join(", ", startAreas)} ]";
                    LogHelper.Info(info);
                    return NewSimpleResult(2, info);
                }
@@ -1005,7 +926,7 @@
        }

        /// <summary>
        /// 余料回库/尾箱回库(PDA)
        /// 尾料回库/余料回库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
@@ -1013,8 +934,10 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.W尾箱回库;
            var endAreaName = "";
            var taskInfo = Settings.GetTaskInfo(ETask.W尾料回库);
            var taskName = taskInfo.TaskName;
            var startAreas = taskInfo.StartAreas;
            List<string> endAreas = null;
            
            try {
                var startLoc = db.Queryable<TN_Location>()
@@ -1041,17 +964,17 @@

                TN_Location endLoc = null;
                if (locCntrRel.S_CNTR_TYPE == "托盘") {
                    endAreaName = AreaName.M满托货架区;
                    endAreas = taskInfo.EndAreas_Pallet;
                    endLoc = db.Queryable<TN_Location>()
                        .Where(l => Settings.AreaMap[endAreaName].Contains(l.S_AREA_CODE))
                        .Where(l => endAreas.Contains(l.S_AREA_CODE))
                        .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y") // 筛选：未上锁
                        .Where(l => l.N_CURRENT_NUM == 0)
                        .First();
                }
                else if (locCntrRel.S_CNTR_TYPE == "好运箱"){
                    endAreaName = AreaName.M满箱货架区;
                    endAreas = taskInfo.EndAreas_Goodpack;
                    endLoc = db.Queryable<TN_Location>()
                        .Where(l => Settings.AreaMap[endAreaName].Contains(l.S_AREA_CODE))
                        .Where(l => endAreas.Contains(l.S_AREA_CODE))
                        .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y") // 筛选：未上锁
                        .Where(l => l.N_CURRENT_NUM == 0)
                        .First();
@@ -1126,7 +1049,8 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.C成品胶出库;
            var taskInfo = Settings.GetTaskInfo(ETask.C成品胶出库);
            var taskName = taskInfo.TaskName;

            try {
                var orderNo = GenerateOrderNo("出库单号", "CKD");
@@ -1197,7 +1121,8 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.C成品胶出库;
            var taskInfo = Settings.GetTaskInfo(ETask.C成品胶出库);
            var taskName = taskInfo.TaskName;

            try {
                var orderNo = GenerateOrderNo("出库单号", "CKD");

 api/MoboxController.cs

@@ -9,26 +9,26 @@

namespace HH.WCS.Mobox3.DSZSH.api {
    /// <summary>
    /// Mobox3 调用，脚本中调用（包括 PDA 的接口）
    /// Mobox / PDA 接口
    /// </summary>
    [RoutePrefix("api")]
    public class MoboxController : ApiController {
        /// <summary>
        /// 好运箱-满箱下线入库(PDA)
        /// 满箱下线入库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("goodpack-offline")]
        public SimpleResult GoodpackOffline(GoodpackOfflineInfo model) {
            var apiName = "好运箱-满托下线入库(PDA)";
            var apiName = "满箱下线入库";
            LogHelper.InfoApi(apiName, model);

            return ApiHelper.GoodpackOffline(model);
        }

        /// <summary>
        /// 空托/空箱入库(PDA)
        /// 空托/空箱入库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>

 config/config.comment.json

@@ -1,73 +1,70 @@
{
    //"WebApiUrl": "http://192.168.1.141:8901",
    //"WebApiUrl": "http://192.168.1.67:8901",
    "WebApiUrl": "http://127.0.0.1:8901",
    "NdcApiUrl": "http://127.0.0.1:5201/api/order/",
    "ErpApiUrl": "http://127.0.0.1:8085/api/",
    //"SqlServer": "Data Source=192.168.1.87;Initial Catalog=AMS_OIMobox;User ID=sa;Password=123456;",
    "SqlServer": "Data Source=(local);Initial Catalog=DSZSHTest;User ID=sa;Password=123456;",
    "WebApiUrl": "http://127.0.0.1:8901", // 后台接口访问地址
    "NdcApiUrl": "http://127.0.0.1:5201/api/order/", // NDC接口地址 
    "ErpApiUrl": "http://127.0.0.1:8901/api/", // ERP接口地址
    "SqlServer": "Data Source=192.168.1.87;Initial Catalog=AMS_OIMobox;User ID=sa;Password=123456;", // 数据库配置地址
    "TcpServerIp": "127.0.0.1",
    "TcpServerPort": 8085,
    "Areas": [
    "TaskInfo": [ // 任务起点终点配置（不能改变任务的相对位置）
        {
            "Name": "包装区",
            "Codes": [ "BZQ" ]
            "TaskName": "好运箱-满箱下线入库", // 任务名称
            "StartAreas": [ "MXCZQ" ], // 起点货区：满箱存放区
            "EndAreas": [ "MXHJQ" ] // 终点货区：满箱货架区
        },
        {
            "Name": "空箱操作区",
            "Codes": [ "KXCZQ" ]
            "TaskName": "好运箱-空箱上线",
            "StartAreas": [ "KXHJQ" ], // 空箱货架区
            "EndAreas": [ "KXCZQ" ] // 空箱操作区
        },
        {
            "Name": "满箱操作区",
            "Codes": [ "MXCZQ" ]
            "TaskName": "好运箱-空箱入库",
            "StartAreas": [ "KXJBQ1", "KXJBQ2" ], // 空箱入库接驳区1/2
            "EndAreas": [ "KXHJQ" ] // 空箱货架区
        },
        {
            "Name": "空托存放区",
            "Codes": [ "KTCFQ" ]
            "TaskName": "成品胶出库",
            "StartAreas": [ "MTHJQ", "MXHJQ", "HCBHQ", "QCBHQ" ],
            "EndAreas": [ "HCCKQ", "QCCKQ" ]
        },
        {
            "Name": "空箱货架区",
            "Codes": [ "KXHJQ" ]
            "TaskName": "托盘-满托下线入库",
            "StartAreas": [],
            "EndAreas": [ "MTHJQ" ]
        },
        {
            "Name": "满托货架区",
            "Codes": [ "MTHJQ" ]
            "TaskName": "托盘-空托上线",
            "StartAreas": [],
            "EndAreas": []
        },
        {
            "Name": "满箱货架区",
            "Codes": [ "MXHJQ" ]
            "TaskName": "托盘-空托入库",
            "StartAreas": [ "KTJBQ" ], // 空托接驳区
            "EndAreas": [ "KTCFQ" ] // 空托存放区
        },
        {
            "Name": "抽检区",
            "Codes": [ "CJQ" ]
            "TaskName": "抽检-出库",
            "StartAreas": [ "MTHJQ", "MXHJQ" ], // 满托货架区、满箱货架区
            "EndAreas": [ "CJQ" ] // 抽检区
        },
        {
            "Name": "抽检异常区",
            "Codes": [ "CJYCQ" ]
            "TaskName": "抽检-合格回库",
            "StartAreas": [ "CJQ" ], // 抽检区
            "EndAreas": []
        },
        {
            "Name": "空托入库接驳区",
            "Codes": [ "KTJBQ" ]
            "TaskName": "抽检-不合格移库",
            "StartAreas": [ "CJQ" ],
            "EndAreas": []
        },
        {
            "Name": "空箱入库接驳区",
            "Codes": [ "KXJBQ1", "KXJBQ2" ]
            "TaskName": "移库",
            "StartAreas": [],
            "EndAreas": []
        },
        {
            "Name": "汽车出库区",
            "Codes": [ "QCCKQ" ]
        },
        {
            "Name": "火车出库区",
            "Codes": [ "HCCKQ" ]
        },
        {
            "Name": "汽车备货区",
            "Codes": [ "QCBHQ" ]
        },
        {
            "Name": "火车备货区",
            "Codes": [ "HCBHQ" ]
            "TaskName": "尾箱回库",
            "StartAreas": [ "HCCKQ", "QCCKQ" ], // 火车出库区、汽车出库区
            "EndAreas": []
        }
    ],
    "ProductionLines": [
@@ -77,12 +74,8 @@
            "PlcIp": "127.0.0.1",
            "PlcPort": 502,
            "SlaveId": 1,
            "OnLoc": [
                "CX11"
            ],
            "OffLoc": [
                "CX12"
            ]
            "OnLoc": [ "CX11" ],
            "OffLoc": [ "CX12" ]
        },
        {
            "Id": "2",
@@ -90,12 +83,8 @@
            "PlcIp": "127.0.0.1",
            "PlcPort": 503,
            "SlaveId": 2,
            "OnLoc": [
                "CX21"
            ],
            "OffLoc": [
                "CX22"
            ]
            "OnLoc": [ "CX21" ],
            "OffLoc": [ "CX22" ]
        },
        {
            "Id": "3",
@@ -103,12 +92,8 @@
            "PlcIp": "127.0.0.1",
            "PlcPort": 504,
            "SlaveId": 3,
            "OnLoc": [
                "CX31"
            ],
            "OffLoc": [
                "CX32"
            ]
            "OnLoc": [ "CX31" ],
            "OffLoc": [ "CX32" ]
        },
        {
            "Id": "4",
@@ -116,46 +101,8 @@
            "PlcIp": "127.0.0.1",
            "PlcPort": 505,
            "SlaveId": 4,
            "OnLoc": [
                "CX41"
            ],
            "OffLoc": [
                "CX42"
            ]
        }
    ],
    "ProdAgvSite": [
        {
            "Code": "work111",
            "ProdId": 0
        },
        {
            "Code": "work112",
            "ProdId": 0
        },
        {
            "Code": "work121",
            "ProdId": 1
        },
        {
            "Code": "work122",
            "ProdId": 1
        },
        {
            "Code": "work131",
            "ProdId": 2
        },
        {
            "Code": "work132",
            "ProdId": 2
        },
        {
            "Code": "work141",
            "ProdId": 3
        },
        {
            "Code": "work142",
            "ProdId": 3
            "OnLoc": [ "CX41" ],
            "OffLoc": [ "CX42" ]
        }
    ]
}

 config/config.json

@@ -5,66 +5,66 @@
    "SqlServer": "Data Source=192.168.1.87;Initial Catalog=AMS_OIMobox;User ID=sa;Password=123456;",
    "TcpServerIp": "127.0.0.1",
    "TcpServerPort": 8085,
    "Areas": [
    "TaskInfos": [
        {
            "Name": "包装区",
            "Codes": [ "BZQ" ]
            "TaskName": "满托下线入库（托盘）",
            "StartAreas": [ "BZQ" ],
            "EndAreas": [ "MTHJQ" ]
        },
        {
            "Name": "空箱操作区",
            "Codes": [ "KXCZQ" ]
            "TaskName": "满箱下线入库（好运箱）",
            "StartAreas": [ "MXCZQ" ],
            "EndAreas": [ "MXHJQ" ]
        },
        {
            "Name": "满箱操作区",
            "Codes": [ "MXCZQ" ]
            "TaskName": "成品胶出库",
            "StartAreas": [ "MTHJQ", "MXHJQ", "HCBHQ", "QCBHQ" ],
            "EndAreas": [ "HCCKQ", "QCCKQ" ]
        },
        {
            "Name": "空托存放区",
            "Codes": [ "KTCFQ" ]
            "TaskName": "空托上线出库",
            "StartAreas": [ "KTCFQ" ],
            "EndAreas": [ "BZQ" ]
        },
        {
            "Name": "空箱货架区",
            "Codes": [ "KXHJQ" ]
            "TaskName": "空箱上线出库",
            "StartAreas": [ "KXHJQ" ],
            "EndAreas": [ "KXCZQ" ]
        },
        {
            "Name": "满托货架区",
            "Codes": [ "MTHJQ" ]
            "TaskName": "空托入库",
            "StartAreas": [ "KTJBQ" ],
            "EndAreas": [ "KTCFQ" ]
        },
        {
            "Name": "满箱货架区",
            "Codes": [ "MXHJQ" ]
            "TaskName": "空箱入库",
            "StartAreas": [ "KXJBQ1", "KXJBQ2" ],
            "EndAreas": [ "KXHJQ" ]
        },
        {
            "Name": "抽检区",
            "Codes": [ "CJQ" ]
            "TaskName": "抽检出库",
            "StartAreas": [ "MTHJQ", "MXHJQ" ],
            "EndAreas": [ "CJQ" ]
        },
        {
            "Name": "抽检异常区",
            "Codes": [ "CJYCQ" ]
            "TaskName": "抽检合格回库",
            "StartAreas": [ "CJQ" ],
            "EndAreas_Pallet": [ "MTHJQ" ],
            "EndAreas_Goodpack": [ "MXHJQ" ]
        },
        {
            "Name": "空托入库接驳区",
            "Codes": [ "KTJBQ" ]
            "TaskName": "抽检不合格移库",
            "StartAreas": [ "CJQ" ],
            "EndAreas": [ "CJYCQ" ]
        },
        {
            "Name": "空箱入库接驳区",
            "Codes": [ "KXJBQ1", "KXJBQ2" ]
            "TaskName": "尾料回库",
            "StartAreas": [ "HCCKQ", "QCCKQ" ],
            "EndAreas_Pallet": [ "MTHJQ" ],
            "EndAreas_Goodpack": [ "MXHJQ" ]
        },
        {
            "Name": "汽车出库区",
            "Codes": [ "QCCKQ" ]
        },
        {
            "Name": "火车出库区",
            "Codes": [ "HCCKQ" ]
        },
        {
            "Name": "汽车备货区",
            "Codes": [ "QCBHQ" ]
        },
        {
            "Name": "火车备货区",
            "Codes": [ "HCBHQ" ]
            "TaskName": "移库"
        }
    ],
    "ProductionLines": [
@@ -74,12 +74,8 @@
            "PlcIp": "127.0.0.1",
            "PlcPort": 502,
            "SlaveId": 1,
            "OnLoc": [
                "CX11"
            ],
            "OffLoc": [
                "CX12"
            ]
            "OnLoc": [ "BZQ-1-1" ],
            "OffLoc": [ "BZQ12" ]
        },
        {
            "Id": "2",
@@ -87,12 +83,8 @@
            "PlcIp": "127.0.0.1",
            "PlcPort": 503,
            "SlaveId": 2,
            "OnLoc": [
                "CX21"
            ],
            "OffLoc": [
                "CX22"
            ]
            "OnLoc": [ "CX21" ],
            "OffLoc": [ "CX22" ]
        },
        {
            "Id": "3",
@@ -100,12 +92,8 @@
            "PlcIp": "127.0.0.1",
            "PlcPort": 504,
            "SlaveId": 3,
            "OnLoc": [
                "CX31"
            ],
            "OffLoc": [
                "CX32"
            ]
            "OnLoc": [],
            "OffLoc": [ "CX32" ]
        },
        {
            "Id": "4",
@@ -113,46 +101,8 @@
            "PlcIp": "127.0.0.1",
            "PlcPort": 505,
            "SlaveId": 4,
            "OnLoc": [
                "CX41"
            ],
            "OffLoc": [
                "CX42"
            ]
        }
    ],
    "ProdAgvSite": [
        {
            "Code": "work111",
            "ProdId": 0
        },
        {
            "Code": "work112",
            "ProdId": 0
        },
        {
            "Code": "work121",
            "ProdId": 1
        },
        {
            "Code": "work122",
            "ProdId": 1
        },
        {
            "Code": "work131",
            "ProdId": 2
        },
        {
            "Code": "work132",
            "ProdId": 2
        },
        {
            "Code": "work141",
            "ProdId": 3
        },
        {
            "Code": "work142",
            "ProdId": 3
            "OnLoc": [],
            "OffLoc": [ "CX42" ]
        }
    ]
}

 core/Monitor.cs

@@ -74,7 +74,8 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.C成品胶出库;
            var taskInfo = Settings.GetTaskInfo(ETask.C成品胶出库);
            var taskName = taskInfo.TaskName;

            try {
                var orderList = db.Queryable<TN_Outbound_Order>()
@@ -235,7 +236,8 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.C抽检_出库;
            var taskInfo = Settings.GetTaskInfo(ETask.C抽检出库);
            var taskName = taskInfo.TaskName;

            try {
                var orderList = db.Queryable<TN_Spot_Check>()
@@ -360,7 +362,8 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.Y移库;
            var taskInfo = Settings.GetTaskInfo(ETask.Y移库);
            var taskName = taskInfo.TaskName;

            try {
                var orderList = db.Queryable<TN_Relocation_List>()

 core/WCSCore.cs

@@ -76,7 +76,7 @@
                    WCSHelper.UpdateStatus(TN_Task, "取货完成"); // 任务状态改成取货完成
                    TaskProcess.OperateStatus(TN_Task, 4); // 起点容器货位解绑,解锁起点

                    if (TN_Task.S_TYPE == TaskName.C成品胶出库) {
                    if (TN_Task.S_TYPE == ETask.C成品胶出库.Name()) {
                        var nextOutboundTask = Task.Run(() => {
                            UpdateOutboundTaskState(3);
                        });
@@ -128,8 +128,8 @@
                var cgDetail = new TN_CG_Detail(); // 如果没有信息，默认就是空值，可以直接填入，不需要判断
                
                //var emptyTask = false; // 空托/空箱任务
                if (task.S_TYPE != TaskName.H好运箱_空箱上线 && task.S_TYPE != TaskName.H好运箱_空箱入库 &&
                    task.S_TYPE != TaskName.T托盘_空托上线 && task.S_TYPE != TaskName.T托盘_空托入库) {
                if (task.S_TYPE != ETask.K空托上线出库.Name() && task.S_TYPE != ETask.K空托入库.Name() &&
                    task.S_TYPE != ETask.K空箱上线出库.Name() && task.S_TYPE != ETask.K空箱入库.Name()) {
                    // 非空托/空箱任务（空托/空箱任务无法在CGDetail查到物料信息）
                    //emptyTask= true;
                    cgDetail = db.Queryable<TN_CG_Detail>()
@@ -147,8 +147,8 @@

                var isInbound = false; // 入库类型的任务（包括移库类任务）
                var inboundTasks = new List<string> {
                    TaskName.H好运箱_满箱下线入库, TaskName.H好运箱_空箱入库, TaskName.T托盘_满托下线入库, TaskName.T托盘_空托入库,
                    TaskName.C抽检_合格回库, TaskName.C抽检_不合格移库, TaskName.Y移库
                    ETask.M满托下线入库.Name(), ETask.K空箱入库.Name(), ETask.M满托下线入库.Name(), ETask.K空托入库.Name(),
                    ETask.C抽检合格回库.Name(), ETask.C抽检不合格移库.Name(), ETask.Y移库.Name()
                };
                if (inboundTasks.Contains(task.S_TYPE)) {
                    isInbound= true;
@@ -209,11 +209,17 @@
            try {
                ModbusHelper.Relink();

                //var loc = db.Queryable<TN_Location>()
                //    .Where(l => l.S_AGV_SITE == model.station_name && Settings.AreaMap[AreaName.包装区].Contains(l.S_AREA_CODE))
                //    .First();
                var BZQ = Settings.GetTaskInfo(ETask.M满托下线入库).StartAreas;
                var loc = db.Queryable<TN_Location>()
                    .Where(l => BZQ.Contains(l.S_AREA_CODE) && l.S_AGV_SITE == model.station_name).First();

                if (!Settings.AgvSite_ProdLineCodeMap.TryGetValue(model.station_name, out int prodIndex)) {
                if (loc == null) {
                    info = $"AGV 站点{model.station_name}不是合法的产线接驳位站点";
                    LogHelper.Info(info);
                    return NewReturnResult(1, info);
                }

                if (!Settings.LocProdIdMap.TryGetValue(loc.S_CODE, out var prodIndex)) {
                    info = $"AGV 站点{model.station_name}不是合法的产线接驳位站点";
                    LogHelper.Info(info);
                    return NewReturnResult(1, info);
@@ -296,7 +302,7 @@
        }

        public static void UpdateOutboundTaskState(int spotStateCode) {
            var taskName = TaskName.C成品胶出库;
            var taskName = ETask.C成品胶出库.Name();
            var db = new SqlHelper<object>().GetInstance();

            var detail = db.Queryable<TN_Outbound_Detail>()
@@ -524,21 +530,22 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.T托盘_满托下线入库;
            const string startAreaName = AreaName.B包装区;
            const string endAreaName = AreaName.M满托货架区;
            var taskInfo = Settings.GetTaskInfo(ETask.M满托下线入库);
            var taskName = taskInfo.TaskName;
            var startAreas = taskInfo.StartAreas;
            var endAreas = taskInfo.EndAreas;
            const string cntrType = "托盘";

            try {
                var startLoc = db.Queryable<TN_Location>()
                .Where(l => l.S_CODE == startLocCode)
                .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE))
                .Where(l => startAreas.Contains(l.S_AREA_CODE))
                .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                //.Where(l => l.N_CURRENT_NUM == 0) // 绑定前
                .First();

                if (startLoc == null) {
                    info = $"在'{startAreaName}'中没有找到起点货位'{startLocCode}'，或不满足要求：未上锁、当前容器数量=0";
                    info = $"没有找到起点货位'{startLocCode}'，或不满足要求：未上锁、当前容器数量=0";
                    LogHelper.Info(info);
                    return new Result<bool>(false, info);
                }
@@ -556,14 +563,14 @@
                startLoc.N_CURRENT_NUM = 1; // 绑定后

                var endLoc = db.Queryable<TN_Location>()
                    .Where(a => Settings.AreaMap[endAreaName].Contains(a.S_AREA_CODE))
                    .Where(a => endAreas.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) // 筛选：空货位
                    .OrderBy(l => l.N_LAYER)
                    .First();

                if (endLoc == null) {
                    info = $"在终点货区'{endAreaName}'中，没有找到合适的【终点货位】，需要满足要求：未上锁、当前容器数量=0";
                    info = $"没有找到合适的【终点货位】，需要满足要求：未上锁、当前容器数量=0";
                    LogHelper.Info(info);
                    return new Result<bool>(false, info);
                }

 util/Settings.cs

@@ -16,22 +16,15 @@
        public static string SqlServer { get; set; }
        public static string TcpServerIp { get; set; }
        public static int TcpServerPort { get; set; }
        public static List<Config.Area> Areas { get; set; } = new List<Config.Area>();
        public static List<Config.ProductionLine> ProductionLines { get; set; } = new List<Config.ProductionLine>();
        public static List<Config.ProdAgvSite> ProdAgvSites { get; set; } = new List<Config.ProdAgvSite>();
        /// <summary>
        /// 库区字典（加载后就不变）
        /// </summary>
        public static Dictionary<string, List<string>> AreaMap { get; set; } = new Dictionary<string, List<string>>();

        public static Dictionary<string, int> AgvSite_ProdLineCodeMap { get; set; } = new Dictionary<string, int>();
        public static List<Config.TaskInfo> TaskInfos { get; set; } = new List<Config.TaskInfo> { };

        public static Dictionary<string, int> LocProdIdMap { get; set; } = new Dictionary<string, int> { };

        public static void Init() {
            // 加载配置文件
            LoadJson();

            // 针对 Areas 进行转换：将 Config 的 List 加载到 Dict 中
            LoadAreas();
        }

        private static void LoadJson() {
@@ -52,14 +45,17 @@
                SqlServer = root.SqlServer;
                TcpServerIp = root.TcpServerIp;
                TcpServerPort = root.TcpServerPort;
                Areas = root.Areas;
                ProductionLines = root.ProductionLines;
                TaskInfos = root.TaskInfos;

                ProdAgvSites = root.ProdAgvSite;
                foreach (var item in ProdAgvSites) {
                    AgvSite_ProdLineCodeMap.Add(item.Code, item.ProdId);
                for (var i = 0; i < ProductionLines.Count; i++) {
                    foreach (var onLoc in ProductionLines[i].OnLoc) {
                        LocProdIdMap.Add(onLoc, int.Parse(ProductionLines[i].Id));
                    }
                    foreach (var offLoc in ProductionLines[i].OffLoc) {
                        LocProdIdMap.Add(offLoc, int.Parse(ProductionLines[i].Id));
                    }
                }

            }   
            catch (FileNotFoundException) {
                LogHelper.Info("JSON 文件未找到");
@@ -73,12 +69,6 @@
            LogHelper.Info("加载配置文件信息 完成");
        }

        private static void LoadAreas() {
            foreach (var area in Areas) {
                AreaMap.Add(area.Name, area.Codes);
            }
        }

        private static void LoadProdLines() {
            //var db = new SqlHelper<object>().GetInstance();
            //for (int  i = 0;  i < ProductionLines.Count;  i++) {
@@ -87,6 +77,9 @@
            //}
        }

        public static Config.TaskInfo GetTaskInfo(ETask eTask) {
            return TaskInfos[(int)eTask];
        }
    }

    // [Convert JSON to C# Classes Online - Json2CSharp Toolkit](https://json2csharp.com/)
@@ -94,16 +87,6 @@
    public class Config {

        // Root myDeserializedClass = JsonConvert.DeserializeObject<Root>(myJsonResponse);
        public class Area {
            public string Name { get; set; }
            public List<string> Codes { get; set; }
        }

        public class ProdAgvSite {
            public string Code { get; set; }
            public int ProdId { get; set; }
        }

        public class ProductionLine {
            public string Id { get; set; }
            public string Name { get; set; }
@@ -121,53 +104,37 @@
            public string SqlServer { get; set; }
            public string TcpServerIp { get; set; }
            public int TcpServerPort { get; set; }
            public List<Area> Areas { get; set; }

            public List<TaskInfo> TaskInfos { get; set; }
            public List<ProductionLine> ProductionLines { get; set; }
            public List<ProdAgvSite> ProdAgvSite { get; set; }
        }

        public class TaskInfo {
            public string TaskName { get; set; }
            public List<string> StartAreas { get; set; }
            public List<string> EndAreas { get; set; }
            public List<string> EndAreas_Pallet { get; set; }
            public List<string> EndAreas_Goodpack { get; set; }
        }
    }


    public class AreaName {
        public const string B包装区 = "包装区";
        public const string K空箱操作区 = "空箱操作区";
        public const string M满箱操作区 = "满箱操作区";

        public const string K空托存放区 = "空托存放区";
        public const string K空箱货架区 = "空箱货架区";
        public const string M满托货架区 = "满托货架区";
        public const string M满箱货架区 = "满箱货架区";

        public const string C抽检区 = "抽检区";
        public const string C抽检异常区 = "抽检异常区";

        public const string K空托入库接驳区 = "空托入库接驳区";
        public const string K空箱入库接驳区 = "空箱入库接驳区";

        public const string Q汽车出库区 = "汽车出库区";
        public const string H火车出库区 = "火车出库区";
        public const string Q汽车备货区 = "汽车备货区";
        public const string H火车备货区 = "火车备货区";
    public enum ETask {
        M满托下线入库,
        M满箱下线入库,
        C成品胶出库,
        K空托上线出库,
        K空箱上线出库,
        K空托入库,
        K空箱入库,
        C抽检出库,
        C抽检合格回库,
        C抽检不合格移库,
        W尾料回库,
        Y移库,
    }

    public class TaskName {
        public const string H好运箱_满箱下线入库 = "好运箱-满箱下线入库";
        public const string H好运箱_空箱上线 = "好运箱-空箱上线";
        public const string H好运箱_空箱入库 = "好运箱-空箱入库";

        public const string C成品胶出库 = "成品胶出库";

        public const string T托盘_满托下线入库 = "托盘-满托下线入库";
        public const string T托盘_空托上线 = "托盘-空托上线";
        public const string T托盘_空托入库 = "托盘-空托入库";

        public const string C抽检_不合格移库 = "抽检-不合格移库";
        public const string C抽检_出库 = "抽检-出库";
        public const string C抽检_合格回库 = "抽检-合格回库";

        public const string Y移库 = "移库";
        public const string W尾箱回库 = "尾箱回库";
    public static class ETaskExtensions {
        public static string Name(this ETask eTask) {
            return Settings.TaskInfos[(int)eTask].TaskName;
        }
    }

}

 wms/InfoBuilder.cs

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

namespace HH.WCS.Mobox3.DSZSH.wms {
    internal class InfoBuilder {
    }
}

 wms/LocationHelper.cs

@@ -181,32 +181,26 @@
        }

        /// <summary>
        /// 入库锁定终点，出库锁定起点
        /// 
        /// </summary>
        /// <remarks>
        /// 创建任务锁定货位的时候，把锁的来源就是任务号也写上去（加锁的方法加个参数，可空的参数），解锁的时候把来源置空
        /// </remarks>
        /// <param name="loc"></param>
        /// <param name="lockState">1:入库锁、2:出库锁、3:其它锁</param>
        /// <param name="lockSource">锁的来源=任务号</param>
        /// <param name="db"></param>
        /// <param name="nCurrentNum"></param>
        /// <param name="areas"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        private static bool LockLoc(string loc, int lockState, string lockSource = "")
        {
            var res = false;
            var db = new SqlHelper<object>().GetInstance();
            var model = db.Queryable<TN_Location>().Where(a => a.S_CODE == loc).First();
            LogHelper.Info($"锁货位{loc},状态{lockState},信息" + JsonConvert.SerializeObject(model));
            if (model != null && model.N_LOCK_STATE == 0)
            {
                model.N_LOCK_STATE = lockState;
                model.S_LOCK_STATE = TN_Location.GetLockStateStr(lockState);
                model.S_LOCK_OP = lockSource;
                model.T_MODIFY = System.DateTime.Now;
                res = db.Updateable<TN_Location>(model).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() > 0;
            }
            LogHelper.Info($"锁货位{loc}返回{res}");
        public static ISugarQueryable<TN_Location> GetLocQuery(SqlSugarClient db, int nCurrentNum = 0, List<string> areas = null, string name = null) {
            var query = db.Queryable<TN_Location>()
                .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && l.N_CURRENT_NUM == nCurrentNum);

            return res;
            if (areas != null && !areas.Any()) {
                query = query.Where(l => areas.Contains(l.S_AREA_CODE));
            }

            if (!string.IsNullOrEmpty(name)) {
                query = query.Where(l => l.S_CODE == name);
            }

            return query;
        }

        /// <summary>