内部联调测试，修复产品入库货区判断逻辑等问题

kazelee

2025-05-22 bb09e7affb602791af4064cda8cddcfae8b3f3aa

内部联调测试，修复产品入库货区判断逻辑等问题

 .vs/HH.WCS.Mobox3.AnGang/FileContentIndex/1a441e71-f454-4033-af8e-db39c2339a05.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.AnGang/FileContentIndex/3ea34f60-d704-4ad2-8e0f-2cf457081645.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.AnGang/FileContentIndex/c94de693-d780-402e-840f-826433af2f96.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.AnGang/FileContentIndex/d649a959-a553-4855-aaba-982999a405f5.vsidx

Binary files differ

 HH.WCS.Mobox3.AnGang.csproj

@@ -290,7 +290,6 @@
    <Compile Include="models\TN_Container.cs" />
    <Compile Include="models\TN_Location.cs" />
    <Compile Include="models\TN_Loc_Container.cs" />
    <Compile Include="models\TN_WorkOrder.cs" />
    <Compile Include="models\TN_Task.cs" />
    <Compile Include="models\TN_Task_Action.cs" />
    <Compile Include="process\DeviceProcess.cs" />

 Models/TN_CG_Detail.cs

@@ -19,6 +19,8 @@

        public string S_ITEM_CODE { get; set; } = "";//货品编码

        public string S_ITEM_NAME { get; set; } = "";

        public string S_ITEM_SPEC { get; set; } = "";//货品规格

        /// <summary>
@@ -38,9 +40,7 @@
        /// </summary>
        public float F_QTY { get; set; } = 0f;

        /// <summary>
        /// 图片链接
        /// </summary>
        public string S_IMG_URL { get; set; } = "";


    }
}

 Models/TN_Loc_Container.cs

@@ -16,5 +16,10 @@

        [Navigate(NavigateType.OneToOne, nameof(S_CNTR_CODE))]
        public TN_Container Container { get; set; }

        /// <summary>
        /// 图片链接
        /// </summary>
        public string S_IMG_URL { get; set; } = "";
    }
}

 Models/TN_WorkOrder.cs

File was deleted

 Program.cs

@@ -3,11 +3,14 @@
using System.Threading;
using System.Threading.Tasks;

using HH.WCS.Mobox3.AnGang.core;
using HH.WCS.Mobox3.AnGang.device;

using Microsoft.Owin.Hosting;

using Topshelf;

using Monitor = HH.WCS.Mobox3.AnGang.core.Monitor;

namespace HH.WCS.Mobox3.AnGang {
    internal class Program
@@ -123,8 +126,8 @@
            {
                List<Task> tasks = new List<Task>();
                // 添加任务推送线程
                //tasks.Add(GetTask(WCSCore.Dispatch));

                tasks.Add(GetTask(WCSCore.Dispatch));
                tasks.Add(GetTask(Monitor.CheckCountOrder));


                Task.WaitAll(tasks.ToArray());

 api/ApiHelper.cs

@@ -27,16 +27,18 @@
                    .Where(a => a.S_CODE == model.StartLoc)
                    .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y")
                    .Where(a => a.N_CURRENT_NUM == 0)
                    .Where(a => a.S_AREA_CODE == "SFQ")
                    .Where(a => Settings.Areas[0].Contains(a.S_AREA_CODE)) // 收发区
                    .First();

                if (startLoc == null) {
                    return NewSimpleResult(1, $"起点位置{model.StartLoc}不存在！");
                    return BuildSimpleResult(1, $"起点位置{model.StartLoc}不存在！");
                }

                // 容器 ID 和 物料 ID 未指定，由系统直接生成
                var cntId = Guid.NewGuid().ToString("D");
                var CgId = Guid.NewGuid().ToString("D");
                //var cntId = Guid.NewGuid().ToString("D");
                //var CgId = Guid.NewGuid().ToString("D");
                var cntId = GenerateNo("容器号", "CN");
                var cgId = GenerateNo("物料号", "CG");

                // 初始是没有绑定信息的，先将起点位置与容器绑定，容器与物料绑定
                var locCntrRel = new TN_Loc_Container() {
@@ -44,7 +46,7 @@
                    S_CNTR_CODE = cntId,
                };
                var cgDetail = new TN_CG_Detail() {
                    S_ITEM_CODE = CgId,
                    S_ITEM_CODE = cgId,
                    S_CNTR_CODE = cntId,
                };

@@ -54,11 +56,11 @@
                if (model.Row != null && model.Row.Trim() != "") {
                    endLocCode = model.Row; // 用排号字符串当做假地址
                    if (!int.TryParse(model.Row.Trim(), out int row)) {
                        return NewSimpleResult(2, $"{model.Row} 不合法：无法转成整数类型");
                        return BuildSimpleResult(2, $"{model.Row} 不合法：无法转成整数类型");
                    }
                    // 货架排号只能是 0 - 8
                    if (row <= 0 || row > 8) {
                        return NewSimpleResult(2, $"货架号 {model.Row} 必须是1-8之间的整数");
                        return BuildSimpleResult(2, $"货架号 {model.Row} 必须是1-8之间的整数");
                    }
                }

@@ -69,38 +71,44 @@
                using (var tran = db.Ado.UseTran()) {
                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"插入货位容器关系表失败：货位{locCntrRel.S_LOC_CODE}，容器{locCntrRel.S_CNTR_CODE}");
                    }

                    if (db.Insertable<TN_CG_Detail>(cgDetail).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"插入容器货品明细表失败：容器{cgDetail.S_CNTR_CODE}，物料{cgDetail.S_ITEM_CODE}");
                    }

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

                    if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"生成任务 {taskName} 失败：容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货架 {endLocCode} ，终点货位未指定");
                    }

                    tran.CommitTran();
                    return NewSimpleResult(0,
                    return BuildSimpleResult(0,
                        $"生成任务 {taskName} 成功：容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货架 {endLocCode} ，终点货位未指定");
                }
            }
            catch (Exception ex) {
                return NewSimpleResult(1, $"发生了异常：{ex.Message}");
                return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
            }
        }

        //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')}";
        //}

        /// <summary>
        /// PDA选择终点货位
@@ -118,18 +126,18 @@
                    .OrderBy(a => a.T_CREATE, SqlSugar.OrderByType.Desc).First();

                if (task == null) {
                    return NewSimpleResult(2, $"当前不存在状态为 取货完成 的 产品入库 任务");
                    return BuildSimpleResult(2, $"当前不存在状态为 取货完成 的 产品入库 任务");
                }

                if (task.S_END_LOC != null && task.S_END_LOC != "0") {
                    return NewSimpleResult(3, $"该任务已有终点");
                    return BuildSimpleResult(3, $"该任务已有终点");
                }

                var cgDetail = db.Queryable<TN_CG_Detail>()
                    .Where(a => a.S_CNTR_CODE == task.S_CNTR_CODE).First();

                if (cgDetail == null) {
                    return NewSimpleResult(4, $"托盘物料不存在");
                    return BuildSimpleResult(4, $"托盘物料不存在");
                }

                var endLoc = new TN_Location();
@@ -139,7 +147,7 @@
                        .Where(a => a.S_CODE == model.endLoc)
                        .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y")
                        .Where(a => a.N_CURRENT_NUM == 0)
                        .Where(a => a.S_AREA_CODE == "HJQ")
                        .Where(a => Settings.Areas[1].Contains(a.S_AREA_CODE))
                        .Where(a => a.N_LAYER <= 3)
                        .First();
                }
@@ -148,17 +156,17 @@
                        .Where(a => a.S_CODE == model.endLoc)
                        .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y")
                        .Where(a => a.N_CURRENT_NUM == 0)
                        .Where(a => a.S_AREA_CODE == "HJQ")
                        .Where(a => Settings.Areas[1].Contains(a.S_AREA_CODE))
                        //.Where(a => a.N_LAYER <= 3)
                        .First();
                }
                else {
                    return NewSimpleResult(5, $"物料重量信息不合法：{cgDetail.F_QTY}");
                    return BuildSimpleResult(5, $"物料重量信息不合法：{cgDetail.F_QTY}");
                }

                // 没有符合条件的货位
                if (endLoc == null) {
                    return NewSimpleResult(6, $"货位{model.endLoc}不存在，或不满足称重放置要求");
                    return BuildSimpleResult(6, $"货位{model.endLoc}不存在，或不满足称重放置要求");
                }

                // 修改任务终点为PDA指定终点
@@ -168,21 +176,21 @@
                using (var tran = db.Ado.UseTran()) {
                    if (db.Updateable<TN_Task>(task).UpdateColumns(a => a.S_END_LOC).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(7, $"任务{task.S_CODE}修改失败，修改终点位置为{endLoc.S_CODE}");
                        return BuildSimpleResult(7, $"任务{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 NewSimpleResult(7, $"任务{task.S_CODE}修改失败，修改终点位置为{endLoc.S_CODE}");
                        return BuildSimpleResult(7, $"任务{task.S_CODE}修改失败，修改终点位置为{endLoc.S_CODE}");
                    }

                    tran.CommitTran();
                    return NewSimpleResult(0, $"任务{task.S_CODE}修改成功，修改终点位置为{endLoc.S_CODE}");
                    return BuildSimpleResult(0, $"任务{task.S_CODE}修改成功，修改终点位置为{endLoc.S_CODE}");
                }
            }
            catch (Exception ex) {
                return NewSimpleResult(1, $"发生了异常：{ex.Message}");
                return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
            }
        }

@@ -204,19 +212,19 @@
                    .First();

                if (startLoc == null) {
                    return NewSimpleResult(2, $"起点位置 {model.startLoc} 不存在或不具备取货要求");
                    return BuildSimpleResult(2, $"起点位置 {model.startLoc} 不存在或不具备取货要求");
                }

                var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);

                if (locCntrRel == null) {
                    return NewSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可出库的物料");
                    return BuildSimpleResult(3, $"起点位置 {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" && a.S_AREA_CODE == "SFQ");
                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" && Settings.Areas[0].Contains(a.S_AREA_CODE));

                if (endLoc == null) {
                    return NewSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                    return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                }

                var cntId = locCntrRel.S_CNTR_CODE;
@@ -229,7 +237,7 @@
                    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 NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}");
                    }

@@ -237,23 +245,23 @@
                        it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY }).ExecuteCommand() <= 0) {

                        tran.RollbackTran();
                        return NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }

                    if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }

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

@@ -268,20 +276,20 @@

            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" && a.S_AREA_CODE == "SFQ");
                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 NewSimpleResult(2, $"起点位置 {model.startLoc} 不符合回库条件");
                    return BuildSimpleResult(2, $"起点位置 {model.startLoc} 不符合回库条件");
                }

                var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
                if (locCntrRel == null) {
                    return NewSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
                    return BuildSimpleResult(3, $"起点位置 {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 NewSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                    return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                }

                var cntId = locCntrRel.S_CNTR_CODE;
@@ -293,30 +301,30 @@
                    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 NewSimpleResult(500,
                        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 NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }

                    if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }

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

@@ -336,19 +344,19 @@
                    countPlan.S_ITEM_CODE = model.targetId;
                }
                else {
                    return NewSimpleResult(2, $"创建盘点计划失败：不合法的盘点类型 '{model.countType}'");
                    return BuildSimpleResult(2, $"创建盘点计划失败：不合法的盘点类型 '{model.countType}'");
                }

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

                return NewSimpleResult(0, "创建盘点计划成功");
                return BuildSimpleResult(0, "创建盘点计划成功");

            }
            catch (Exception ex) {

                return NewSimpleResult(1, ex.Message);
                return BuildSimpleResult(1, ex.Message);
            }
        }

@@ -360,7 +368,7 @@
                    .Where(a => a.S_CP_NO == model.planId).First();

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

                var countOrder = new TN_Count_Order() {
@@ -398,30 +406,30 @@
                    }
                }
                else {
                    return NewSimpleResult(3, $"计划单'{model.planId}'的类型{countPlan.S_TYPE}不合法");
                    return BuildSimpleResult(3, $"计划单'{model.planId}'的类型{countPlan.S_TYPE}不合法");
                }

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

                    if (db.Insertable<TN_Count_CG_Detail>(countDetailList).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = "创建盘点单明细失败";
                        return NewSimpleResult(3, info); 
                        return BuildSimpleResult(3, info); 
                    }

                    tran.CommitTran();
                }

                return NewSimpleResult(0, "创建盘点单成功");
                return BuildSimpleResult(0, "创建盘点单成功");
            }
            catch (Exception ex) {

                return NewSimpleResult(1, $"发生了异常：{ex.Message}");
                return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
            }
        }

@@ -432,30 +440,31 @@
                    .Where(d => d.S_CNTR_CODE == model.cntrCode).First();

                if (cgDetail == null) {
                    return NewSimpleResult(2, $"找不到容器号'{model.cntrCode}'对应的物料");
                    return BuildSimpleResult(2, $"找不到容器号'{model.cntrCode}'对应的物料");
                }

                var countDiff = new TN_Count_Diff {
                    S_CNTR_CODE = cgDetail.S_CNTR_CODE,
                    F_QTY = cgDetail.F_QTY,
                    F_ACTUAL_QTY = model.qty
                };

                if (db.Insertable<TN_Count_Diff>(countDiff).ExecuteCommand() <= 0) {
                    return NewSimpleResult(3, $"插入盘点差异表失败");
                    return BuildSimpleResult(3, $"插入盘点差异表失败");
                }

                return NewSimpleResult(0, "盘点差异完成");
                return BuildSimpleResult(0, "盘点差异完成");

            }
            catch (Exception ex) {
                return NewSimpleResult(1, $"发生了异常：{ex.Message}");
                return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
            }
        }

        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')}";
            return $"{prefix}{date}{id.ToString().PadLeft(4, '0')}";
        }

        /// <summary>
@@ -469,20 +478,20 @@

            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" && a.S_AREA_CODE == "SFQ");
                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 NewSimpleResult(2, $"起点位置 {model.startLoc} 不符合出库条件");
                    return BuildSimpleResult(2, $"起点位置 {model.startLoc} 不符合出库条件");
                }

                var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
                if (locCntrRel == null) {
                    return NewSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
                    return BuildSimpleResult(3, $"起点位置 {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 NewSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                    return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                }

                var cntID = locCntrRel.S_CNTR_CODE;
@@ -494,30 +503,30 @@
                    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 NewSimpleResult(500,
                        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 NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }

                    if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }

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

@@ -532,20 +541,20 @@

            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" && a.S_AREA_CODE == "SFQ");
                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 NewSimpleResult(2, $"起点位置 {model.startLoc} 不符合回库条件");
                    return BuildSimpleResult(2, $"起点位置 {model.startLoc} 不符合回库条件");
                }

                var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
                if (locCntrRel == null) {
                    return NewSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
                    return BuildSimpleResult(3, $"起点位置 {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 NewSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                    return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                }

                var cntID = locCntrRel.S_CNTR_CODE;
@@ -557,56 +566,107 @@
                    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 NewSimpleResult(500,
                        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 NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }

                    if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500,
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntID} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    }

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

        public static ErpResult InboundDataSync(InboundDataSyncInfo model) {
            var db = new SqlHelper<object>().GetInstance();

            try {
                var err = "";
                var cgDetailList = new List<TN_CG_Detail>();
                foreach (var inboundData in model.stockTransactions) {
                    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 == inboundData.locationCode)
                        .Select((l, c, d) => d)
                        .First();
                    
                    if (cgDetail == null) {
                        err += $"储位码{inboundData.locationCode}对应的货位物料不存在！";
                        continue;
                    }

                    cgDetail.S_ITEM_CODE = inboundData.itemCode;
                    cgDetail.S_ITEM_NAME = inboundData.itemName;
                    
                    cgDetailList.Add(cgDetail);
                }
                
                if (db.Updateable<TN_CG_Detail>(cgDetailList).ExecuteCommand() <= 0) {
                    return BuildErpResult(500, $"更改物料信息失败");
                }

                if (err != "") {
                    return BuildErpResult(2, err);
                }
                return BuildErpResult(0, $"更改物料信息成功");

            }
            catch (Exception ex) {
                return BuildErpResult(1, ex.Message);
                return BuildErpResult(1, $"发生了异常：{ex.Message}");
            }
            return BuildErpResult(0, null);
        }

        public static ErpResult OutboundDataSync(OutboundDataSyncInfo model) {
            var db = new SqlHelper<object>().GetInstance();

            try {
                var err = "";
                var cgDetailList = new List<TN_CG_Detail>();
                foreach (var inboundData in model.materialIssues) {
                    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 == inboundData.locationCode)
                        .Select((l, c, d) => d)
                        .First();

                    if (cgDetail == null) {
                        err += $"储位码{inboundData.locationCode}对应的货位物料不存在！";
                        continue;
                    }

                    cgDetail.S_ITEM_CODE = inboundData.itemCode;
                    cgDetail.S_ITEM_NAME = inboundData.itemName;

                    cgDetailList.Add(cgDetail);
                }

                if (db.Updateable<TN_CG_Detail>(cgDetailList).ExecuteCommand() <= 0) {
                    return BuildErpResult(500, $"更改物料信息失败");
                }

                if (err != "") {
                    return BuildErpResult(2, err);
                }
                return BuildErpResult(0, $"更改物料信息成功");

            }
            catch (Exception ex) {
                return BuildErpResult(1, ex.Message);
                return BuildErpResult(1, $"发生了异常：{ex.Message}");
            }
            return BuildErpResult(1, null);
        }
    }
}

 api/ApiModel.cs

@@ -17,7 +17,8 @@
            public List<object> result { get; set; } = new List<object>();
        }

        public static SimpleResult NewSimpleResult(int code, string message) {
        public static SimpleResult BuildSimpleResult(int code, string message) {
            LogHelper.Info(message);
            return new SimpleResult { resultCode = code, resultMsg = message };
        }


 api/DebugController.cs

@@ -100,57 +100,61 @@
            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;
        ///// <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),
        //        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);
                        }
        //        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.InitTables(entityTypes);

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

                    tran.CommitTran();
                }
        //            tran.CommitTran();
        //        }

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

            return "成功";
        }
        //    return "成功";
        //}

        /// <summary>
        /// DEBUG：插入货位、容器、货品信息
@@ -247,6 +251,11 @@
            }
        }

        /// <summary>
        /// DEBUG：根据任务号设置物料重量
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("SetTaskWeight")]
        public string SetTaskWeight(SetTaskWeightInfo model) {

 api/ErpController.cs

@@ -15,7 +15,7 @@
        /// <returns></returns>
        [HttpPost]
        [Route("InboundDataSync")]
        public static ErpResult InboundDataSync(InboundDataSyncInfo model) {
        public ErpResult InboundDataSync(InboundDataSyncInfo model) {
            return ApiHelper.InboundDataSync(model);
        }

@@ -26,7 +26,7 @@
        /// <returns></returns>
        [HttpPost]
        [Route("OutboundDataSync")]
        public static ErpResult OutboundDataSync(OutboundDataSyncInfo model) {
        public ErpResult OutboundDataSync(OutboundDataSyncInfo model) {
            return ApiHelper.OutboundDataSync(model);
        }
    }

 api/MoboxController.cs

@@ -83,22 +83,29 @@
            return ApiHelper.CreateCountOrder(model);
        }
 
        /// <summary>
        /// 盘点理货(PDA)
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("CountProduct")]
        public SimpleResult CountProduct(CountProductInfo model) {
            LogHelper.Info("触发API：盘点理货(PDA)" + JsonConvert.SerializeObject(model), "API");
            return ApiHelper.CountProduct(model);
        }

        /// <summary>
        /// 盘点理货出库(WMS)
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("CheckOutbound")]
        public SimpleResult CheckOutbound(CheckOutboundInfo model) {
            LogHelper.Info("触发API：盘点理货出库(WMS)" + JsonConvert.SerializeObject(model), "API");
            return ApiHelper.CheckOutbound(model);
        }
        ///// <summary>
        ///// 盘点理货出库(WMS)
        ///// </summary>
        ///// <param name="model"></param>
        ///// <returns></returns>
        //[HttpPost]
        //[Route("CheckOutbound")]
        //public SimpleResult CheckOutbound(CheckOutboundInfo model) {
        //    LogHelper.Info("触发API：盘点理货出库(WMS)" + JsonConvert.SerializeObject(model), "API");
        //    return ApiHelper.CheckOutbound(model);
        //}

        /// <summary>
        /// 盘点理货回库(WMS)

 config/config.json

@@ -2,13 +2,13 @@
    "WebApiUrl": "http://127.0.0.1:8901",
    "RCSApiUrl": "http://127.0.0.1:6001",
    "NDCApiUrl": "http://127.0.0.1:5201/api/order/",
    "SqlServer": "Data Source=(local);Initial Catalog=AnGangTest;User ID=sa;Password=123456",
    "SqlServer": "Data Source=192.168.1.144;Initial Catalog=YinKouAnGan;User ID=hhuser;Password=Hh123321&&",
    "TCPServerIP": "127.0.0.1",
    "TCPServerPort": 8085,
    "Areas": [
        {
            "Name": "收发区",
            "Codes": [ "SFQ" ]
            "Name": "取放货区",
            "Codes": [ "QFHQ" ]
        },
        {
            "Name": "货架区",

 core/Monitor.cs

@@ -27,7 +27,7 @@
                    .ToList();

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

@@ -45,34 +45,21 @@
                        continue;
                    }

                    var lastDetail = db.Queryable<TN_Count_CG_Detail>()
                        .Where(d => d.S_COUNT_NO == order.S_COUNT_NO && d.N_B_STATE == 2) // TODO 或者改成查task
                        .First();
                    if (lastDetail != null) {
                        LogHelper.Info($"轮询--{taskName}--{taskName}单'{order.S_COUNT_NO}'上一个任务仍在进行中："
                            + JsonConvert.SerializeObject(lastDetail));
                        continue;
                    }

                    var outboundDetail = db.Queryable<TN_Count_CG_Detail>()
                    var countCgDetailList = db.Queryable<TN_Count_CG_Detail>()
                        .Where(a => a.S_COUNT_NO == order.S_COUNT_NO && a.N_B_STATE == 1) // 已下发
                        .First();
                    if (outboundDetail != null) {
                        LogHelper.Info($"轮询--{taskName}--");
                        .ToList();

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

                    detailList.Add(outboundDetail);
                    detailList.AddRange(countCgDetailList);
                }

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

                var startLocList = new List<TN_Location>();
                var endLocList = new List<TN_Location>();

                var taskList = new List<TN_Task>();

                foreach (var detail in detailList) {
                    var startLoc = db.Queryable<TN_Location>()
@@ -81,17 +68,17 @@
                        .First();

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

                    var endLoc = db.Queryable<TN_Location>()
                        .Where(a => a.S_AREA_CODE == "SFQ")
                        .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($"轮询--出库：没有找到合适的终点货位！S_NO为 '{detail.S_COUNT_NO}'");
                        LogHelper.Info($"轮询--{taskName}：没有找到合适的终点货位！单号为 '{detail.S_COUNT_NO}'");
                        continue;
                    }

@@ -106,7 +93,7 @@
                    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($"轮询--出库--修改明细表状态为完成失败！");
                            LogHelper.Info($"轮询--{taskName}--修改明细表状态为完成失败！");
                        }

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

                            tran.RollbackTran();
                            info = $"生成 {taskName} 失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}";
                            info = $"生成'{taskName}'失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}";
                            LogHelper.Info(info);
                            continue;
                        }
@@ -144,7 +131,7 @@
                        tran.CommitTran();
                        info = $"生成 {taskName} 成功，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}";
                        LogHelper.Info(info);
                        continue;
                        //continue;
                    }
                }
            }

 core/WCSCore.cs

@@ -74,6 +74,7 @@
                    if (TN_Task.S_TYPE == TaskName.产品入库 || TN_Task.S_TYPE == TaskName.产品部分回库) {
                        var captureTask = Task.Run(() => {
                            CapturePic(TN_Task);
                            LogHelper.Info("拍照Task结束");
                        });
                    }

@@ -81,6 +82,14 @@
                        var setEndLocTask = Task.Run(() => {
                            // 只要任务为产品入库(PDA)，就需要重新指定终点（默认endLoc为""）
                            SetEndLoc(TN_Task);
                            LogHelper.Info("设置终点Task结束");
                        });
                    }

                    if (TN_Task.S_TYPE == TaskName.产品部分回库) {
                        var weightTask = Task.Run(() => {
                            UpdateWeight(TN_Task);
                            LogHelper.Info("称重Task结束");
                        });
                    }

@@ -111,13 +120,14 @@
        public static void CapturePic(TN_Task model) {
            var db = new SqlHelper<object>().GetInstance();

            try {
            var filepath = SnapManager.GetCapturePicturePath();
            if (string.IsNullOrEmpty(filepath)) {
                LogHelper.Info("图片地址为空");
                return;
            }

            if (db.Updateable<TN_CG_Detail>()
                if (db.Updateable<TN_Loc_Container>()
                .SetColumns(d => d.S_IMG_URL == filepath)
                .Where(d => d.S_CNTR_CODE == model.S_CNTR_CODE).ExecuteCommand() <= 0) {

@@ -125,9 +135,15 @@
                return;
            }
        }
            catch (Exception ex) {
                LogHelper.Info($"发生了错误：{ex.Message}");
            }
        }

        public static void SetEndLoc(TN_Task tn_task) {
            var db = new SqlHelper<object>().GetInstance();
            var info = "";
            try {
            var endLoc = db.Queryable<TN_Location>()
                .First(a => a.S_CODE == tn_task.S_END_LOC);

@@ -193,7 +209,7 @@

            // 如果没有符合条件的货位，置空，等待PDA重新确定
            if (endLoc == null) {
                tn_task.S_END_AREA = "HJQ";
                    tn_task.S_END_AREA = Settings.Areas[1][0]; // HJQ
                tn_task.S_END_LOC = "0";

                // 不需要再给GZ AGV传空值，一开始就没给具体货位，只给了Area
@@ -218,16 +234,68 @@
                // 找到合适的货位，推送
                tn_task.S_END_LOC = endLoc.S_CODE;

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

                    using (var tran = db.Ado.UseTran()) {
                if (db.Updateable<TN_Task>(tn_task).UpdateColumns(it => new { it.S_END_LOC })
                        .ExecuteCommand() > 0) {
                    LocationHelper.LockLoc(endLoc.S_CODE, 1);//终点入库锁
                    LogHelper.Info($"计算货位成功，任务 {tn_task.S_CODE} 修改成功，终点货架为 {endLoc.N_ROW}，修改终点位置为 {endLoc.S_CODE}");
                            .ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            LogHelper.Info($"计算货位成功，任务'{tn_task.S_CODE}'修改失败，终点货架为{endLoc.N_ROW}，修改终点位置为 {endLoc.S_CODE}");
                }
                else {
                    LogHelper.Info($"计算货位成功，任务 {tn_task.S_CODE} 修改失败，终点货架为 {endLoc.N_ROW}，修改终点位置为 {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();
                            info = $"更新终点货位锁状态失败：起点货位{endLoc.S_CODE}";
                            LogHelper.Info(info);
                        }

                        tran.CommitTran();
                }
            }
        }
            catch (Exception ex) {
                LogHelper.Info($"发生了错误：{ex.Message}");
            }
        }

        public static void UpdateWeight(TN_Task tn_task) {
            var db = new SqlHelper<object>().GetInstance();

            try {

                var cgDetail = db.Queryable<TN_CG_Detail>()
                    .Where(d => d.S_CNTR_CODE == tn_task.S_CNTR_CODE).First();

                if (cgDetail == null) {
                    LogHelper.Info("更新物料重量失败：当前任务的托盘号在物料表中不存在");
                    return;
                }

                var data = GZRobot.CustomBuf();

                if (data.Count == 0) {
                    LogHelper.Info("更新物料重量失败：没有接受到来自国自AGV的重量信息");
                    return;
                }

                var weight = float.Parse(data[0].parameter_varchar200_up);
                cgDetail.F_QTY = weight;

                if (db.Updateable<TN_CG_Detail>(cgDetail).UpdateColumns(it => it.F_QTY).ExecuteCommand() <= 0) {
                    LogHelper.Info("修改物料表重量失败");
                    return;
                }

            }
            catch (Exception ex) {
                LogHelper.Info($"发生了错误：{ex.Message}");
            }

        }

        /// <summary>
        /// 任务分发，根据调度类型发给不同的调度系统

 device/SnapDevice.cs

@@ -51,7 +51,7 @@
                }
                _LoginID = NETClient.LoginWithHighLevelSecurity(ip, uPort, name, pwd, EM_LOGIN_SPAC_CAP_TYPE.TCP, IntPtr.Zero, ref _DeviceInfo);
                if (IntPtr.Zero == _LoginID) {
                    LogHelper.Info(NETClient.GetLastError());
                    LogHelper.Info("相机初始化错误：" + NETClient.GetLastError());
                    return;
                }
                //_channalList.Clear();

 models/TN_Count_CG_Detail.cs

@@ -11,7 +11,7 @@
    /// 盘点单明细表
    /// </summary>
    [SugarTable("TN_Count_CG_Detail")]
    public class TN_Count_CG_Detail {
    public class TN_Count_CG_Detail : BaseModel {
        public string S_COUNT_NO { get; set; }
        public string S_ITEM_CODE { get; set; }
        public string S_CNTR_CODE { get; set; }

 util/Settings.cs

@@ -17,21 +17,22 @@
        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; }
        //public static List<Config.Area> Areas { get; set; }
        public static List<List<string>> Areas { get; set; } = new List<List<string>>();
        public static List<Config.Snap> Snaps { get; set; }
        public static string CaptureUrl { get; set; }

        /// <summary>
        /// 库区字典（加载后就不变）
        /// </summary>
        public static Dictionary<string, List<string>> AreaMap { get; set; } = new Dictionary<string, List<string>>();
        //public static Dictionary<string, List<string>> AreaMap { get; set; } = new Dictionary<string, List<string>>();

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

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

        private static void LoadJson() {
@@ -52,7 +53,10 @@
                SqlServer = root.SqlServer;
                TCPServerIP = root.TCPServerIP;
                TCPServerPort = root.TCPServerPort;
                Areas = root.Areas;
                //Areas = root.Areas;
                foreach (var item in root.Areas) {
                    Areas.Add(item.Codes);
                }
                Snaps = root.Snaps;
                CaptureUrl = root.CaptureUrl;

@@ -70,9 +74,9 @@
        }

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


 util/SqlHelper.cs

@@ -56,6 +56,10 @@
                });
            };

            //db.Aop.OnLogExecuting = (sql, pars) => {
            //    Console.WriteLine(sql);
            //};

            //据转换 (ExecuteCommand才会拦截，查询不行)
            //db.Aop.DataExecuting = (value, entity) => {
            //    //var val=entity.EntityColumnInfo

 wms/WCSHelper.cs

@@ -65,7 +65,7 @@

        public static TN_Task BuildInboundTask(TN_Location startLoc, string endLocCode, string cntId) {
            var type = TaskName.产品入库;
            var endArea = "HJQ";
            var endArea = Settings.Areas[1][0]; // HJQ

            TN_Task TN_Task = new TN_Task() {
                S_CODE = GenerateTaskNo(),
@@ -101,7 +101,7 @@
            var endArea = "";
            if (endLoc == null) {
                if (taskType == TaskName.产品入库) {
                    endArea = "HJQ"; // 货架区
                    endArea = Settings.Areas[1][0]; // HJQ
                }
                else {
                    LogHelper.Info("终点货位不存在，且任务类型不是PDA货品入库");