更新容器必须检查前台是否维护的功能

kazelee

2025-06-11 9fa293298c53429e8ac5148de8328933c0a80ff4

更新容器必须检查前台是否维护的功能

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/3051f4c7-a03d-4ed5-a59d-3d04bff3e616.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/3b98bb07-94dd-4668-8e48-2d4c81bfe8f5.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/5c630563-0c2e-4c9a-b0ed-88f0f49d2377.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/b2279396-cedf-4e13-9379-f9b937f2b7c7.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/bd3ccb48-a785-4e86-8285-4198f2483a17.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/d4ee5337-1afa-4e11-9fd2-caeaeefa2394.vsidx

Binary files differ

 api/ApiHelper.cs

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

                
                // 查询起点货位，是否符合要求（初次下线要求货位无容器）
                // 注：起点货位绑定前没有货物，数量为 0
                var startLoc = db.Queryable<TN_Location>()
@@ -63,57 +63,20 @@
                    .First();

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

                startLoc.N_CURRENT_NUM = 1; // 绑定后，修改起点货位数量为 1

                // 绑定货位和容器号（满箱下线到操作区，此时尚未绑定）
                var locCntrRel = new TN_Loc_Container {
                    S_LOC_CODE = model.StartLoc,
                    S_CNTR_CODE = cgDetail.S_CNTR_CODE,
                    S_LOC_CODE = startLoc.S_CODE, // 已校验
                    S_CNTR_CODE = cgDetail.S_CNTR_CODE, // 已校验
                    S_CNTR_TYPE = "好运箱",
                };

                var needInsertContainer = false;
                var needUpdateContainer = false;

                // 查容器信息表是否已经有这个容器
                var cntr = db.Queryable<TN_Container>()
                    .Where(c => c.S_CODE == locCntrRel.S_CNTR_CODE).First();
                // 如果找不到该容器，需要添加，并且将容器来源设置为任务名称
                if (cntr == null) {
                    needInsertContainer = true;
                    LogHelper.Info($"起点货位的容器：{locCntrRel.S_CNTR_CODE}，在容器表中没有登记，登记并设置容器来源为：{taskName}");

                    cntr = new TN_Container {
                        S_CODE = locCntrRel.S_CNTR_CODE,
                        S_SPEC = cgDetail.S_ITEM_CODE, // 登记容器对应的物料编号 
                        S_TYPE = "料箱", // 容器类型：料箱（好运箱）
                        S_SOURCE = taskName,
                    };
                }
                else {
                    // 如果容器存在，但没有类型或没有适用的物料编号，需要更新，并将容器来源设置为任务名称
                    if (string.IsNullOrEmpty(cntr.S_TYPE)) {
                        needUpdateContainer = true;
                        LogHelper.Info($"起点货位的容器：{locCntrRel.S_CNTR_CODE}，在容器表中登记但没有类型，" +
                            $"更新类型为：料箱，并设置容器来源为：{taskName}");

                        cntr.S_TYPE = "料箱"; // 容器类型：料箱（好运箱）
                        cntr.S_SOURCE = taskName;
                    }
                    if (string.IsNullOrEmpty(cntr.S_SPEC)) {
                        needUpdateContainer = true;
                        LogHelper.Info($"起点货位的容器：{locCntrRel.S_CNTR_CODE}，在容器表中登记但没有适用物料编码，" +
                            $"更新物料编码为：{cgDetail.S_ITEM_CODE}，并设置容器来源为：{taskName}");

                        cntr.S_SPEC = cgDetail.S_ITEM_CODE; // 规格：物料编号
                        cntr.S_SOURCE = taskName;
                    }
                }
                // NOTE 不需要校验locCntrRel的容器是否存在，博实下发物料已经做过校验
                
                // TODO 满箱入库算法待优化
                var endLoc = db.Queryable<TN_Location>()
@@ -126,10 +89,9 @@
                if (endLoc == null) {
                    info = $"在'{endAreaName}'中没有找到合适的终点货位，需要满足：未上锁、无货物";
                    LogHelper.Info(info);
                    return NewSimpleResult(4, info);
                    return NewSimpleResult(3, info);
                }

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

@@ -138,23 +100,6 @@

                // 数据库操作事务部分：错误编码：500
                using (var tran = db.Ado.UseTran()) {
                    if (needInsertContainer) {
                        if (db.Insertable<TN_Container>(cntr).ExecuteCommand() <= 0) {
                            info = $"插入容器表失败：" + JsonConvert.SerializeObject(cntr);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }
                    else if (needUpdateContainer) {
                        if (db.Updateable<TN_Container>(cntr).ExecuteCommand() <= 0) {
                            info = $"更新容器表失败：" + JsonConvert.SerializeObject(cntr);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        info = $"插入货位容器关系失败：" + JsonConvert.SerializeObject(locCntrRel);
                        tran.RollbackTran();
@@ -179,7 +124,7 @@
                        it.N_LOCK_STATE,
                        it.S_LOCK_STATE,
                        it.S_LOCK_OP,
                        it.T_MODIFY
                        it.T_MODIFY,
                    }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败：更新终点货位{endLoc.S_CODE}锁状态失败";
@@ -203,7 +148,7 @@
            catch (Exception ex) {
                info = $"发生了异常：{ex.Message}";
                LogHelper.InfoEx(ex);
                return NewSimpleResult(1, info);
                return NewSimpleResult(-1, info);
            }
        }

@@ -234,9 +179,27 @@
                    .First();

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

                // TEMP 目前流程：容器必须先在系统中维护，否则报错
                // - 后台程序不可以生成Container，必须由前台维护
                // - 否则，工人随意输入一个容器/输入错容器号，都可以绑定
                var cntr = db.Queryable<TN_Container>()
                    .Where(c => c.S_CODE == model.CntrCode) // 对于前台程序而言，S_CODE就是主键，维护时必定唯一
                    .First();

                if (cntr == null) {
                    info = $"容器'{model.CntrCode}'在容器表中不存在，请在前台页面中维护！";
                    LogHelper.Info(info);
                    return NewSimpleResult(2, info);
                }
                if (cntr.S_TYPE != "托盘") { // 空托入库
                    info = $"容器'{model.CntrCode}'在容器表中的类型为'{cntr.S_TYPE}'，与输入的容器类型'托盘'不同！";
                    LogHelper.Info(info);
                    return NewSimpleResult(3, info);
                }

                // 假定人工不会将有物料的箱子放在空箱入库接驳位，没有必要检查
@@ -254,45 +217,16 @@
                        .Where(l => l.S_CODE == locCntrRelOld.S_LOC_CODE).First();
                    if (locOld != null) {
                        locOld.N_CURRENT_NUM = 0; // 如果旧货位存在，将旧货位的数量设置为 0
                        locOld.T_MODIFY = DateTime.Now;
                    }
                }

                // 绑定货位和容器号（PDA在接驳位绑定）
                var locCntrRel = new TN_Loc_Container {
                    S_LOC_CODE = model.StartLoc,
                    S_CNTR_CODE = model.CntrCode,
                    S_CNTR_TYPE = "托盘",
                    S_LOC_CODE = startLoc.S_CODE,
                    S_CNTR_CODE = cntr.S_CODE,
                    S_CNTR_TYPE = "托盘", // 空托入库
                };

                var needInsertContainer = false;
                var needUpdateContainer = false;

                // 查容器信息表是否已经有这个容器
                var cntr = db.Queryable<TN_Container>()
                    .Where(c => c.S_CODE == locCntrRel.S_CNTR_CODE).First();
                // 如果找不到该容器，需要添加，并且将容器来源设置为任务名称
                if (cntr == null) {
                    needInsertContainer = true;
                    LogHelper.Info($"起点货位的容器：{locCntrRel.S_CNTR_CODE}，在容器表中没有登记，登记并设置容器来源为：{taskName}");

                    cntr = new TN_Container {
                        S_CODE = locCntrRel.S_CNTR_CODE,
                        S_SPEC = "", // 空托，物料编码先设置为空
                        S_TYPE = locCntrRel.S_CNTR_TYPE, // 容器类型：托盘
                        S_SOURCE = taskName,
                    };
                }
                else {
                    // 如果容器存在，但没有类型或没有适用的物料编号，需要更新，并将容器来源设置为任务名称
                    if (string.IsNullOrEmpty(cntr.S_TYPE)) {
                        needUpdateContainer = true;
                        LogHelper.Info($"起点货位的容器：{locCntrRel.S_CNTR_CODE}，在容器表中登记但没有类型，" +
                            $"更新类型为：托盘，并设置容器来源为：{taskName}");

                        cntr.S_TYPE = "托盘"; // 容器类型：托盘
                    }
                    // 空托不更新物料编码
                }

                // TODO 暂定选择最低层按区位顺序入库，后面待修改
                var endLoc = db.Queryable<TN_Location>()
@@ -315,29 +249,12 @@
                LocationHelper.LockEndLoc(ref endLoc); // 终点入库锁

                using (var tran = db.Ado.UseTran()) {
                    if (needInsertContainer) {
                        if (db.Insertable<TN_Container>(cntr).ExecuteCommand() <= 0) {
                            info = $"插入容器表失败：" + JsonConvert.SerializeObject(cntr);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }
                    else if (needUpdateContainer) {
                        if (db.Updateable<TN_Container>(cntr).ExecuteCommand() <= 0) {
                            info = $"更新容器表失败：" + JsonConvert.SerializeObject(cntr);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }

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

@@ -346,16 +263,16 @@
                            info = $"删除旧货位容器关系失败：" + JsonConvert.SerializeObject(locCntrRelOld);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(5, info);
                            return NewSimpleResult(500, info);
                        }
                    }

                    if (locOld != null) {
                        if (db.Updateable<TN_Location>(locOld).UpdateColumns(l => l.N_CURRENT_NUM).ExecuteCommand() <= 0) {
                        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(5, info);
                            return NewSimpleResult(500, info);
                        }
                    }

@@ -363,7 +280,7 @@
                        info = $"插入货位容器关系失败：" + JsonConvert.SerializeObject(locCntrRel);
                        tran.RollbackTran();
                        LogHelper.Info(info);
                        return NewSimpleResult(5, info);
                        return NewSimpleResult(500, info);
                    }
                     
                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
@@ -375,7 +292,7 @@
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败：更新起点货位{startLoc.S_CODE}锁状态失败";
                        LogHelper.Info(info);
                        return NewSimpleResult(5, info);
                        return NewSimpleResult(500, info);
                    }

                    if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
@@ -387,14 +304,14 @@
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败：更新终点货位{endLoc.S_CODE}锁状态失败";
                        LogHelper.Info(info);
                        return NewSimpleResult(5, info);
                        return NewSimpleResult(500, info);
                    }

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

                    tran.CommitTran();
@@ -440,6 +357,24 @@
                    return NewSimpleResult(2, info);
                }

                // TEMP 目前流程：容器必须先在系统中维护，否则报错
                // - 后台程序不可以生成Container，必须由前台维护
                // - 否则，工人随意输入一个容器/输入错容器号，都可以绑定
                var cntr = db.Queryable<TN_Container>()
                    .Where(c => c.S_CODE == model.CntrCode) // 对于前台程序而言，S_CODE就是主键，维护时必定唯一
                    .First();

                if (cntr == null) {
                    info = $"容器'{model.CntrCode}'在容器表中不存在，请在前台页面中维护！";
                    LogHelper.Info(info);
                    return NewSimpleResult(2, info);
                }
                if (cntr.S_TYPE != "好运箱") { // 空箱入库
                    info = $"容器'{model.CntrCode}'在容器表中的类型为'{cntr.S_TYPE}'，与输入的容器类型'好运箱'不同！";
                    LogHelper.Info(info);
                    return NewSimpleResult(2, info);
                }

                // 假定人工不会将有物料的箱子放在空箱入库接驳位，没有必要检查
                // 如果人工将出库后的托盘入库，这时物料信息并没有删除，需要将托盘物料的关系解除
                var cgDetailOld = db.Queryable<TN_CG_Detail>()
@@ -460,40 +395,10 @@

                // 绑定货位和容器号
                var locCntrRel = new TN_Loc_Container {
                    S_LOC_CODE = model.StartLoc,
                    S_CNTR_CODE = model.CntrCode,
                    S_LOC_CODE = startLoc.S_CODE,
                    S_CNTR_CODE = cntr.S_CODE,
                    S_CNTR_TYPE = "好运箱",
                };

                var needInsertContainer = false;
                var needUpdateContainer = false;

                // 查容器信息表是否已经有这个容器
                var cntr = db.Queryable<TN_Container>()
                    .Where(c => c.S_CODE == locCntrRel.S_CNTR_CODE).First();
                // 如果找不到该容器，需要添加，并且将容器来源设置为任务名称
                if (cntr == null) {
                    needInsertContainer = true;
                    LogHelper.Info($"起点货位的容器：{locCntrRel.S_CNTR_CODE}，在容器表中没有登记，登记并设置容器来源为：{taskName}");

                    cntr = new TN_Container {
                        S_CODE = locCntrRel.S_CNTR_CODE,
                        S_SPEC = "", // 空箱，物料编码先设置为空
                        S_TYPE = locCntrRel.S_CNTR_TYPE, // 容器类型：料箱（好运箱）
                        S_SOURCE = taskName,
                    };
                }
                else {
                    // 如果容器存在，但没有类型或没有适用的物料编号，需要更新，并将容器来源设置为任务名称
                    if (string.IsNullOrEmpty(cntr.S_TYPE)) {
                        needUpdateContainer = true;
                        LogHelper.Info($"起点货位的容器：{locCntrRel.S_CNTR_CODE}，在容器表中登记但没有类型，" +
                            $"更新类型为：料箱，并设置容器来源为：{taskName}");

                        cntr.S_TYPE = "料箱"; // 容器类型：料箱（好运箱）
                    }
                    // 空箱不更新物料编码
                }

                // TODO 暂定选择最低层顺序入库，后面待修改
                var endLoc = db.Queryable<TN_Location>()
@@ -516,23 +421,6 @@
                LocationHelper.LockEndLoc(ref endLoc); // 终点入库锁

                using (var tran = db.Ado.UseTran()) {
                    if (needInsertContainer) {
                        if (db.Insertable<TN_Container>(cntr).ExecuteCommand() <= 0) {
                            info = $"插入容器表失败：" + JsonConvert.SerializeObject(cntr);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }
                    else if (needUpdateContainer) {
                        if (db.Updateable<TN_Container>(cntr).ExecuteCommand() <= 0) {
                            info = $"更新容器表失败：" + JsonConvert.SerializeObject(cntr);
                            tran.RollbackTran();
                            LogHelper.Info(info);
                            return NewSimpleResult(500, info);
                        }
                    }

                    if (cgDetailOld != null) {
                        if (db.Deleteable<TN_CG_Detail>(cgDetailOld).ExecuteCommand() <= 0) {
                            info = $"删除旧物料信息失败：" + JsonConvert.SerializeObject(cgDetailOld);
@@ -617,7 +505,7 @@
        /// <remarks>
        /// 人工根据当前生产物料所需的容器类型，呼叫AGV从空容器货架中叫一个符合要求的托盘
        /// </remarks>
        /// <param name="model">b包含：容器号、物料编码</param>
        /// <param name="model">包含：容器号、物料编码</param>
        /// <returns></returns>
        public static SimpleResult EmptyOnlinePallet(EmptyOnlinePalletInfo model) {
            var db = new SqlHelper<object>().GetInstance();
@@ -630,22 +518,37 @@
            try {
                // 查容器信息表是否已经有这个容器
                var cntr = db.Queryable<TN_Container>()
                    .Where(c => c.S_CODE == model.CntId).First();
                // 如果表中存在这个托盘信息，但容器类型、物料类型与上线所需物料不符，报错
                // 如果不存在，不作限制（视作第一次上线）
                if (cntr != null) { 
                    // 如果存在容器号，但类型不是托盘，报错
                    if (!string.IsNullOrEmpty(cntr.S_TYPE) && cntr.S_TYPE != "托盘") {
                        info = $"容器在容器表中找到，但类型是：{cntr.S_TYPE}，不是{taskName}所需的：托盘";
                        LogHelper.Info(info);
                        return NewSimpleResult(1, info);
                    }
                    // 如果表中物料编码不为空，且与上线所需物料不一致，报错
                    if (!string.IsNullOrEmpty(cntr.S_SPEC) && cntr.S_SPEC != model.ItemCode) {
                        info = $"容器{model.CntId}已经与物料类型{cntr.S_SPEC}绑定，无法用于装载物料{model.ItemCode}";
                        LogHelper.Info(info);
                        return NewSimpleResult(2, info);
                    }
                    .Where(c => c.S_CODE == model.CntId)
                    .First();

                // 如果容器在容器表中不存在，报错
                if (cntr == null) {
                    info = $"容器'{model.CntId}'在容器表中不存在，请在前台页面中维护！";
                    LogHelper.Info(info);
                    return NewSimpleResult(1, info);
                }
                // 如果存在容器号，但类型不是托盘，报错
                if (cntr.S_TYPE != "托盘") { // 容器类型默认不会为空
                    info = $"容器'{model.CntId}'在容器表中的类型是'{cntr.S_TYPE}，不是'托盘'！";
                    LogHelper.Info(info);
                    return NewSimpleResult(2, info);
                }

                var needUpdateContainer = false;
                if (string.IsNullOrEmpty(cntr.S_SPEC)) {
                    // TEMP 目前流程：如果容器表中规格（物料编码）为空，根据流程的物料信息写入
                    // 待定：后面可能会更改流程，或者用其他信息（如物料类型/规格）作为容器的规格

                    needUpdateContainer = true;
                    info = $"容器'{model.CntId}'在容器表中规格（物料编码）为空，将物料编码'{model.ItemCode}'写入容器的规格";
                    LogHelper.Info(info);

                    cntr.S_SPEC = model.ItemCode;
                }
                else if (cntr.S_SPEC != model.ItemCode) {
                    info = $"容器'{model.CntId}'已经与物料类型'{cntr.S_SPEC}'绑定，无法用于装载物料'{model.ItemCode}'";
                    LogHelper.Info(info);
                    return NewSimpleResult(3, info);
                }

                var startLoc = db.Queryable<TN_Location>()
@@ -680,7 +583,20 @@
                LocationHelper.LockStartLoc(ref startLoc); // 起点出库锁
                LocationHelper.LockEndLoc(ref endLoc); // 终点入库锁

                cntr.S_SOURCE = task.S_CODE; // 用任务号作为容器更新的依据
                cntr.T_MODIFY = DateTime.Now;

                using (var tran = db.Ado.UseTran()) {
                    if (needUpdateContainer) {
                        if (db.Updateable<TN_Container>(cntr)
                            .UpdateColumns(c => new { c.S_SPEC, c.S_SOURCE, c.T_MODIFY }).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            info = $"更新表'{taskName}'失败：更新起点货位{startLoc.S_CODE}锁状态失败";
                            LogHelper.Info(info);
                            return NewSimpleResult(4, info);
                        }
                    }

                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE,
                        it.S_LOCK_STATE,
@@ -721,7 +637,7 @@
            catch (Exception ex) {
                info = $"发生了异常：{ex.Message}";
                LogHelper.InfoEx(ex);
                return NewSimpleResult(1, info);
                return NewSimpleResult(-1, info);
            }
        }

@@ -739,6 +655,25 @@
            var endAreaName = AreaName.K空箱操作区;

            try {
                // 查容器信息表是否已经有这个容器
                var cntr = db.Queryable<TN_Container>()
                    .Where(c => c.S_CODE == model.CntId)
                    .First();

                // 如果容器在容器表中不存在，报错
                if (cntr == null) {
                    info = $"容器'{model.CntId}'在容器表中不存在，请在前台页面中维护！";
                    LogHelper.Info(info);
                    return NewSimpleResult(1, info);
                }
                // 如果存在容器号，但类型不是托盘，报错
                if (cntr.S_TYPE != "托盘") { // 容器类型默认不会为空
                    info = $"容器'{model.CntId}'在容器表中的类型是'{cntr.S_TYPE}，不是'好运箱'！";
                    LogHelper.Info(info);
                    return NewSimpleResult(2, info);
                }
                // NOTE 好运箱只需要关注在不在，不需要关心其适用物料类型

                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)
@@ -996,7 +931,7 @@
                    .First();

                if (startLoc == null) {
                    info = "没有找到合适的起点货位";
                    info = "待抽检物料在抽检区中没有找到！";
                    LogHelper.Info(info);
                    return NewSimpleResult(0, info);
                }
@@ -1008,7 +943,9 @@
                    .First();

                if (endLoc == null) {
                    return NewSimpleResult(3, "查询：没有找到合适的终点货位");
                    info = "查询：没有找到合适的终点货位";
                    LogHelper.Info(info);
                    return NewSimpleResult(3, info);
                }

                cgDetail.N_ITEM_STATE = 2;
@@ -1442,6 +1379,22 @@
                    return NewMesResult(400, info);
                }

                // TEMP 目前流程：对博实下发的信息也进行检查，未找到就报错，后面有需求再更改
                var cntr = db.Queryable<TN_Container>()
                    .Where(c => c.S_CODE == model.CntrCode) // 对于前台程序而言，S_CODE就是主键，维护时必定唯一
                    .First();

                if (cntr == null) {
                    info = $"容器'{model.CntrCode}'在容器表中不存在，请在前台页面中维护！";
                    LogHelper.Info(info);
                    return NewMesResult(1, info);
                }
                if (cntr.S_TYPE != "好运箱") {
                    info = $"容器'{model.CntrCode}'在容器表中的类型为'{cntr.S_TYPE}'，与当前容器类型'好运箱'不同！";
                    LogHelper.Info(info);
                    return NewMesResult(2, info);
                }

                // 将下发的信息先存储到CG表中（此时托盘没有与产线处的货位绑定）
                var detail = new TN_CG_Detail {
                    S_ITEM_CODE = model.ItemCode, // NOT NULL
@@ -1482,7 +1435,7 @@
            catch (Exception ex) {
                info = $"发生了异常：{ex.Message}";
                LogHelper.InfoEx(ex);
                return NewMesResult(1, info);
                return NewMesResult(-1, info);
            }
        }


 api/ApiModel.cs

@@ -206,7 +206,7 @@
            public string StartLoc { get; set; }
        }
        /// <summary>
        /// 空箱上线信息
        /// 空托上线信息
        /// </summary>
        public class EmptyOnlinePalletInfo {
            /// <summary>
@@ -394,6 +394,13 @@
            public string Data { get; set; }
        }

        /// <summary>
        /// 仅当 Code = 0 表示成功
        /// </summary>
        /// <param name="code"></param>
        /// <param name="message"></param>
        /// <param name="printLog"></param>
        /// <returns></returns>
        public static MesResult NewMesResult(int code, string message = "", bool printLog = true) {
            return new MesResult {
                Result = code,

 core/Monitor.cs

@@ -68,6 +68,8 @@

                    var needInsertContainer = false;
                    var needUpdateContainer = false;

                    // TEMP 自动触发的托盘下线暂时不考虑判断，默认没有时写入
                    // 查容器信息表是否已经有这个容器
                    var cntr = db.Queryable<TN_Container>()
                        .Where(c => c.S_CODE == cntrCode).First();
@@ -80,7 +82,6 @@
                            S_CODE = cntrCode,
                            S_TYPE = "托盘",
                            S_SPEC = itemCode,
                            S_SOURCE = taskName,
                        };
                    }
                    else {
@@ -91,7 +92,6 @@
                                $"与所需要的物料信息{itemCode}不符，直接覆盖结果");

                            cntr.S_SPEC = itemCode;
                            cntr.S_SOURCE = taskName;
                        }
                    }

@@ -134,6 +134,9 @@
                    LocationHelper.LockStartLoc(ref startLoc); // 起点出库锁
                    LocationHelper.LockEndLoc(ref endLoc); // 终点入库锁

                    cntr.S_SOURCE = task.S_CODE;
                    cntr.T_MODIFY = DateTime.Now;

                    using (var tran = db.Ado.UseTran()) {
                        if (needInsertContainer) {
                            if (db.Insertable<TN_Container>(cntr).ExecuteCommand() <= 0) {
@@ -144,7 +147,8 @@
                            }
                        }
                        else if (needUpdateContainer) {
                            if (db.Updateable<TN_Container>(cntr).ExecuteCommand() <= 0) {
                            if (db.Updateable<TN_Container>(cntr)
                                .UpdateColumns(c => new { c.S_SPEC, c.S_SOURCE, c.T_MODIFY }).ExecuteCommand() <= 0) {
                                info = $"更新容器表失败：" + JsonConvert.SerializeObject(cntr);
                                tran.RollbackTran();
                                LogHelper.Info(info);

 wms/LocationHelper.cs

@@ -257,29 +257,29 @@
                    location.S_LOCK_STATE = "无";
                    location.N_LOCK_STATE = 0;

                    var containerList = new List<TN_Container>();
                    foreach (var item in lcrList) {
                        // 针对容器类型添加的新逻辑
                        var cntr = db.Queryable<TN_Container>()
                            .Where(c => c.S_CODE == item.S_CNTR_CODE).First();
                        if (cntr == null) {
                            LogHelper.Info($"货位解绑时，容器{item.S_CNTR_CODE}没有在容器信息表中查到，这里根据货位容器关系添加");
                            containerList.Add(new TN_Container {
                                S_CODE = item.S_CNTR_CODE,
                                S_TYPE = item.S_CNTR_TYPE,
                            });
                        }
                    }
                    //var containerList = new List<TN_Container>();
                    //foreach (var item in lcrList) {
                    //    // 针对容器类型添加的新逻辑
                    //    var cntr = db.Queryable<TN_Container>()
                    //        .Where(c => c.S_CODE == item.S_CNTR_CODE).First();
                    //    if (cntr == null) {
                    //        LogHelper.Info($"货位解绑时，容器{item.S_CNTR_CODE}没有在容器信息表中查到，这里根据货位容器关系添加");
                    //        containerList.Add(new TN_Container {
                    //            S_CODE = item.S_CNTR_CODE,
                    //            S_TYPE = item.S_CNTR_TYPE,
                    //        });
                    //    }
                    //}

                    using (var tran = db.Ado.UseTran())
                    {
                        if (containerList.Count > 0) {
                            if (db.Insertable<TN_Container>(containerList).ExecuteCommand() <= 0) {
                                LogHelper.Info($"插入容器信息表失败" + JsonConvert.SerializeObject(containerList));
                                tran.RollbackTran();
                                return "货位解绑容器失败，" + logs;
                            }
                        }
                        //if (containerList.Count > 0) {
                        //    if (db.Insertable<TN_Container>(containerList).ExecuteCommand() <= 0) {
                        //        LogHelper.Info($"插入容器信息表失败" + JsonConvert.SerializeObject(containerList));
                        //        tran.RollbackTran();
                        //        return "货位解绑容器失败，" + logs;
                        //    }
                        //}

                        if (db.Deleteable<TN_Loc_Container>().Where(it => cntrs.Contains(it.S_CNTR_CODE) && it.S_LOC_CODE == loc).ExecuteCommand() > 0)
                        {
@@ -348,7 +348,9 @@
                {
                    // 针对容器类型添加的新逻辑
                    var cntr = db.Queryable<TN_Container>()
                        .Where(c => c.S_CODE == item).First();
                        .Where(c => c.S_CODE == item)
                        .First();

                    if (cntr == null) {
                        LogHelper.Info($"货位解绑时，容器{item}没有在容器信息表中查到，不记录容器类型");
                        bindLocCntList.Add(new TN_Loc_Container() { S_LOC_CODE = loc, S_CNTR_CODE = item });