封装部分业务代码，继续优化日志打印流程

kazelee

昨天 f8d23dcf8d6501482db1a5180325194232afe96c

 api/ApiHelper.cs

@@ -25,83 +25,84 @@
        public static SimpleResult GoodpackOffline(GoodpackOfflineInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var taskInfo = ETask.M满箱下线入库.Info();
            const string preLog = "API：满箱下线入库：";
            const string preLog = "API:满箱下线入库:";
            const string cntrType = "好运箱";

            try {
                if (model.Num <= 0) {
                    return NewSimpleResult(400, preLog + $"物料数量'{model.Num}'不合法！要求：物料数量＞0");
                    return NewSimpleResult(400, preLog + $"物料数量'{model.Num}'不合法!要求:物料数量＞0");
                }

                // 检查货品容器表：是否已经存在贴标机传递的待入库物料信息
                // TODO：数量、规格是否也参与比对？
                // 检查货品容器表:是否已经存在贴标机传递的待入库物料信息
                // TODO:数量,规格是否也参与比对？
                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();
                if (cgDetail == null) {
                    return NewSimpleResult(1, preLog + $"没有在[货品明细表]中找到[物料编码='{model.ItemCode}',批次号='{model.BatchNo}']的物料！请检查：PDA扫码物料信息与贴标机传递的信息是否一致！要求：物料状态='待检'");
                    return NewSimpleResult(1, preLog + $"没有在[货品明细表]中找到[物料编码='{model.ItemCode}',批次号='{model.BatchNo}']的物料!请检查:PDA扫码物料信息与贴标机传递的信息是否一致!要求:物料状态='待检'");
                }

                // 查询起点货位：数量=0
                var startLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y").Where(l => l.S_CODE == model.StartLoc && taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                // 查询起点货位:数量=0
                var startLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && l.S_CODE == model.StartLoc && taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                if (startLoc == null) {
                    return NewSimpleResult(2, preLog + $"没有找到起点货位'{model.StartLoc}'！要求：锁状态='无'，当前容器数量=0，所在库区={LogObject(taskInfo.StartAreas)}");
                    return NewSimpleResult(2, preLog + $"没有找到起点货位'{model.StartLoc}'!要求:锁状态='无',当前容器数量=0,所在库区={LogObject(taskInfo.StartAreas)}");
                }

                // 和满托下线入库的逻辑一致，由于容器移动不会更改绑定信息，所以必须删除旧数据
                var locCntrRelOld = db.Queryable<TN_Loc_Container>()
                    .Where(c => c.S_CNTR_CODE == cgDetail.S_CNTR_CODE).First();
                // 和满托下线入库的逻辑一致,由于容器移动不会更改绑定信息,所以必须删除旧数据
                var old = WCSHelper.GetLocCntrCg(cgDetail.S_CNTR_CODE, skipCgDetail: true);

                // 绑定货位容器，起点货位当前数量=1
                var locCntrRel = new TN_Loc_Container { S_LOC_CODE = startLoc.S_CODE, S_CNTR_CODE = cgDetail.S_CNTR_CODE, S_CNTR_TYPE = cntrType,};
                startLoc.N_CURRENT_NUM = 1;
                // 绑定货位容器,起点货位当前数量=1
                var locCntrRel = WCSHelper.BindLocCntr(ref startLoc, cgDetail.S_CNTR_CODE);
                locCntrRel.S_CNTR_TYPE = cntrType;

                // 查询终点货位
                // Order：按货位层数，从小到大排列
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => taskInfo.EndAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).OrderBy(l => new { l.N_LAYER }).First();
                // Order:按货位层数,从小到大排列
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && taskInfo.EndAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).OrderBy(l => new { l.N_LAYER }).First();
                if (endLoc == null) {
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位！要求：锁状态='无'，当前容器数量=0，所在库区={LogObject(taskInfo.EndAreas)}");
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位!要求:锁状态='无',当前容器数量=0,所在库区={LogObject(taskInfo.EndAreas)}");
                }

                // 起点终点上锁，创建任务
                // 更新[起点/终点]锁状态,创建任务
                WCSHelper.LockStartLoc(ref startLoc);
                WCSHelper.LockEndLoc(ref endLoc);
                var task = WCSHelper.BuildTask(startLoc, endLoc, locCntrRel.S_CNTR_CODE, taskInfo.TaskName);

                using (var tran = db.Ado.UseTran()) {
                    if (locCntrRelOld != null) {
                        if (db.Deleteable(locCntrRelOld).ExecuteCommand() <= 0 &&
                            db.Updateable<TN_Location>().SetColumns(l => l.N_CURRENT_NUM == 0).Where(l => l.S_CODE == locCntrRelOld.S_LOC_CODE).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            return NewSimpleResult(500, preLog + $"删除旧货位容器关系表失败！货位编码={locCntrRelOld.S_LOC_CODE}，容器编码={locCntrRelOld.S_CNTR_CODE}");
                        }
                    // 删除/更新旧[货位/容器/物料]信息
                    if (old.LocCntrRel != null && db.Deleteable(old.LocCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"删除[旧货位容器关系]失败!数据:{LogObject(old.LocCntrRel)}");
                    }
                    if (old.Location != null && db.Updateable(old.Location).UpdateColumns(l => new { l.N_CURRENT_NUM, l.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"更新[旧货位|当前容器数量]失败!货位='{old.Location.S_CODE}',数量=>{old.Location.N_CURRENT_NUM}");
                    }

                    // 插入新绑定的[货位-容器]表
                    if (db.Insertable(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"插入[容器货位绑定表]失败！数据：{LogObject(locCntrRel)}");
                        return NewSimpleResult(500, preLog + $"插入[容器货位绑定表]失败!数据:{LogObject(locCntrRel)}");
                    }

                    // 更新[起点/终点]锁状态,创建任务
                    if (db.Updateable(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();
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败！起点='{startLoc.S_CODE}'，锁状态=>'出库锁'");
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败!起点='{startLoc.S_CODE}',锁状态=>'出库锁'");
                    }

                    if (db.Updateable(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, preLog + $"更新[终点货位锁状态]失败！终点='{endLoc.S_CODE}'，锁状态=>'入库锁'");
                        return NewSimpleResult(500, preLog + $"更新[终点货位锁状态]失败!终点='{endLoc.S_CODE}',锁状态=>'入库锁'");
                    }

                    if (db.Insertable(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                    }

                    // 提交数据库更改
                    tran.CommitTran();
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                }
            }
            catch (Exception ex) {
                return NewSimpleResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewSimpleResult(ex, preLog);
            }
        }

@@ -113,95 +114,86 @@
        public static SimpleResult EmptyInboundPallet(EmptyInboundInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var taskInfo = ETask.K空托入库.Info();
            const string preLog = "API：空托入库：";
            const string preLog = "API:空托入库:";
            const string cntrType = "托盘";

            try {
                // 查询起点货位：数量=0
                var startLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y").Where(l => l.S_CODE == model.StartLoc && taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                // 查询起点货位:数量=0
                var startLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && l.S_CODE == model.StartLoc && taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                if (startLoc == null) {
                    return NewSimpleResult(1, preLog + $"没有找到起点货位'{model.StartLoc}'！要求：锁状态='无'；当前容器数量=0；所在库区={LogObject(taskInfo.StartAreas)}");
                    return NewSimpleResult(1, preLog + $"没有找到起点货位'{model.StartLoc}'!要求:锁状态='无';当前容器数量=0;所在库区={LogObject(taskInfo.StartAreas)}");
                }

                // 查询容器表：容器类型字段
                // 查询容器表:容器类型字段
                var cntr = db.Queryable<TN_Container>().Where(c => c.S_CODE == model.CntrCode).First();
                if (cntr == null) {
                    return NewSimpleResult(2, preLog + $"容器'{model.CntrCode}'在[容器表]中不存在，请在前台页面中维护！");
                    return NewSimpleResult(2, preLog + $"容器'{model.CntrCode}'在[容器表]中不存在,请在前台页面中维护!");
                }
                if (cntr.S_TYPE != cntrType) {
                    return NewSimpleResult(3, preLog + $"容器'{model.CntrCode}'在[容器表]中的类型为'{cntr.S_TYPE}'，与输入的容器类型'{cntrType}'不同！");
                    return NewSimpleResult(3, preLog + $"容器'{model.CntrCode}'在[容器表]中的类型为'{cntr.S_TYPE}',与输入的容器类型'{cntrType}'不同!");
                }
                
                // 空箱入库时,如果存在旧的绑定数据,删除
                var old = WCSHelper.GetLocCntrCg(model.CntrCode);

                // 空箱入库时，如果存在旧的绑定数据，删除
                var cgDetailOld = db.Queryable<TN_CG_Detail>().Where(d => d.S_CNTR_CODE == model.CntrCode).First();
                var locCntrRelOld = db.Queryable<TN_Loc_Container>().Where(c => c.S_CNTR_CODE == model.CntrCode).First();
                TN_Location locOld = null;
                if (locCntrRelOld != null) {
                    locOld = db.Queryable<TN_Location>().Where(l => l.S_CODE == locCntrRelOld.S_LOC_CODE).First();
                    if (locOld != null) {
                        locOld.N_CURRENT_NUM = 0; // 如果旧货位存在，将旧货位的数量设置为 0
                        locOld.T_MODIFY = DateTime.Now;
                    }
                }

                // 绑定货位容器，起点货位当前数量=1
                var locCntrRel = new TN_Loc_Container { S_LOC_CODE = startLoc.S_CODE, S_CNTR_CODE = cntr.S_CODE, S_CNTR_TYPE = cntrType };
                startLoc.N_CURRENT_NUM = 1;
                // 绑定货位容器,起点货位当前数量=1
                var locCntrRel = WCSHelper.BindLocCntr(ref startLoc, cntr.S_CODE);
                locCntrRel.S_CNTR_TYPE = cntrType;

                // 查询终点货位
                // Order：层数从低到高、行、列
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y").Where(l => taskInfo.EndAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).OrderBy(l => new { l.N_LAYER, l.N_ROW, l.N_COL }).First();
                // Order:层数从低到高,行,列
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && taskInfo.EndAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).OrderBy(l => new { l.N_LAYER, l.N_ROW, l.N_COL }).First();
                if (endLoc == null) {
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位！要求：锁状态='无'；当前容器数量=0；所在库区={LogObject(taskInfo.EndAreas)}");
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位!要求:锁状态='无';当前容器数量=0;所在库区={LogObject(taskInfo.EndAreas)}");
                }

                // 起点终点上锁，创建任务
                // 起点终点上锁,创建任务
                WCSHelper.LockStartLoc(ref startLoc);
                WCSHelper.LockEndLoc(ref endLoc);
                var task = WCSHelper.BuildTask(startLoc, endLoc, locCntrRel.S_CNTR_CODE, taskInfo.TaskName);

                using (var tran = db.Ado.UseTran()) {
                    if (cgDetailOld != null && db.Deleteable(cgDetailOld).ExecuteCommand() <= 0) {
                    if (old.CgDetail != null && db.Deleteable(old.CgDetail).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"删除[旧物料信息]失败！数据：{LogObject(cgDetailOld)}");
                        return NewSimpleResult(500, preLog + $"删除[旧物料信息]失败!数据:{LogObject(old.CgDetail)}");
                    }

                    if (locCntrRelOld != null && db.Deleteable(locCntrRelOld).ExecuteCommand() <= 0) {
                    if (old.LocCntrRel != null && db.Deleteable(old.LocCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"删除[旧货位容器关系]失败！数据：{LogObject(locCntrRelOld)}");
                        return NewSimpleResult(500, preLog + $"删除[旧货位容器关系]失败!数据:{LogObject(old.LocCntrRel)}");
                    }

                    if (locOld != null && db.Updateable(locOld).UpdateColumns(l => new { l.N_CURRENT_NUM, l.T_MODIFY }).ExecuteCommand() <= 0) {
                    if (old.Location != null && db.Updateable(old.Location).UpdateColumns(l => new { l.N_CURRENT_NUM, l.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"更新[旧货位|当前容器数量]失败！货位='{locOld.S_CODE}'，数量=>{locOld.N_CURRENT_NUM}");
                        return NewSimpleResult(500, preLog + $"更新[旧货位|当前容器数量]失败!货位='{old.Location.S_CODE}',数量=>{old.Location.N_CURRENT_NUM}");
                    }

                    if (db.Insertable(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"插入[货位容器绑定表]失败！数据：{LogObject(locCntrRel)}");
                        return NewSimpleResult(500, preLog + $"插入[货位容器绑定表]失败!数据:{LogObject(locCntrRel)}");
                    }

                    // 更新[起点/终点]锁状态,创建任务
                    if (db.Updateable(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();
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败！起点='{startLoc.S_CODE}'，锁状态=>'出库锁'");
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败!起点='{startLoc.S_CODE}',锁状态=>'出库锁'");
                    }

                    if (db.Updateable(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, preLog + $"更新[终点货位锁状态]失败！终点='{endLoc.S_CODE}'，锁状态=>'入库锁'");
                        return NewSimpleResult(500, preLog + $"更新[终点货位锁状态]失败!终点='{endLoc.S_CODE}',锁状态=>'入库锁'");
                    }

                    if (db.Insertable(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                    }

                    // 提交数据库更改
                    tran.CommitTran();
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                }
            }
            catch (Exception ex) {
                return NewSimpleResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewSimpleResult(ex, preLog);
            }
        }

@@ -212,46 +204,37 @@
        public static SimpleResult EmptyInboundGoodpack(EmptyInboundInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var taskInfo = ETask.K空箱入库.Info();
            const string preLog = "API：空箱入库：";
            const string preLog = "API:空箱入库:";
            const string cntrType = "好运箱";

            try {
                // 查询起点货位：数量=0
                // 查询起点货位:数量=0
                var startLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y").Where(l => l.S_CODE == model.StartLoc && taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                if (startLoc == null) {
                    return NewSimpleResult(1, preLog + $"没有找到起点货位'{model.StartLoc}'！要求：锁状态='无'；当前容器数量=0；所在库区={LogObject(taskInfo.StartAreas)}");
                    return NewSimpleResult(1, preLog + $"没有找到起点货位'{model.StartLoc}'!要求:锁状态='无';当前容器数量=0;所在库区={LogObject(taskInfo.StartAreas)}");
                }

                // 查询容器表：容器类型字段
                // 查询容器表:容器类型字段
                var cntr = db.Queryable<TN_Container>().Where(c => c.S_CODE == model.CntrCode).First();
                if (cntr == null) {
                    return NewSimpleResult(2, preLog + $"容器'{model.CntrCode}'在[容器表]中不存在，请在前台页面中维护！");
                    return NewSimpleResult(1, $"容器'{model.CntrCode}'在[容器表]中不存在,请在前台页面中维护!");
                }
                if (cntr.S_TYPE != cntrType) {
                    return NewSimpleResult(3, preLog + $"容器'{model.CntrCode}'在[容器表]中的类型为'{cntr.S_TYPE}'，与输入的容器类型'{cntrType}'不同！");
                    return NewSimpleResult(2, preLog + $"容器'{model.CntrCode}'在[容器表]中的类型是'{cntr.S_TYPE},不是'{cntrType}'!");
                }

                // 空箱入库时，如果存在旧的绑定数据，删除
                var cgDetailOld = db.Queryable<TN_CG_Detail>().Where(d => d.S_CNTR_CODE == model.CntrCode).First();
                var locCntrRelOld = db.Queryable<TN_Loc_Container>().Where(c => c.S_CNTR_CODE == model.CntrCode).First();
                TN_Location locOld = null;
                if (locCntrRelOld != null) {
                    locOld = db.Queryable<TN_Location>().Where(l => l.S_CODE == locCntrRelOld.S_LOC_CODE).First();
                    if (locOld != null) {
                        locOld.N_CURRENT_NUM = 0; // 如果旧货位存在，将旧货位的数量设置为 0
                        locOld.T_MODIFY = DateTime.Now;
                    }
                }
                // 空箱入库时,如果存在旧的绑定数据,删除
                var old = WCSHelper.GetLocCntrCg(model.CntrCode);

                // 绑定货位容器，起点货位当前数量=1
                var locCntrRel = new TN_Loc_Container { S_LOC_CODE = startLoc.S_CODE, S_CNTR_CODE = cntr.S_CODE, S_CNTR_TYPE = cntrType };
                startLoc.N_CURRENT_NUM = 1;
                // 绑定货位容器,起点货位当前数量=1
                var locCntrRel = WCSHelper.BindLocCntr(ref startLoc, model.CntrCode);
                locCntrRel.S_CNTR_TYPE = cntrType;

                // 查询终点货位
                // Order：层数从低到高、行、列
                // Order:层数从低到高,行,列
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y").Where(l => taskInfo.EndAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).OrderBy(l => new { l.N_LAYER, l.N_ROW, l.N_COL }).First();
                if (endLoc == null) {
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位！要求：锁状态='无'；当前容器数量=0；所在库区={LogObject(taskInfo.EndAreas)}");
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位!要求:锁状态='无';当前容器数量=0;所在库区={LogObject(taskInfo.EndAreas)}");
                }

                WCSHelper.LockStartLoc(ref startLoc);
@@ -259,47 +242,45 @@
                var task = WCSHelper.BuildTask(startLoc, endLoc, locCntrRel.S_CNTR_CODE, taskInfo.TaskName);

                using (var tran = db.Ado.UseTran()) {
                    if (cgDetailOld != null && db.Deleteable(cgDetailOld).ExecuteCommand() <= 0) {
                    if (old.CgDetail != null && db.Deleteable(old.CgDetail).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"删除[旧物料信息]失败！数据：{LogObject(cgDetailOld)}");
                        return NewSimpleResult(500, preLog + $"删除[旧物料信息]失败!数据:{LogObject(old.CgDetail)}");
                    }

                    if (locCntrRelOld != null && db.Deleteable(locCntrRelOld).ExecuteCommand() <= 0) {
                    if (old.LocCntrRel != null && db.Deleteable(old.LocCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"删除[旧货位容器关系]失败！" + LogObject(locCntrRelOld));
                        return NewSimpleResult(500, preLog + $"删除[旧货位容器关系]失败!数据:{LogObject(old.LocCntrRel)}");
                    }

                    if (locOld != null && db.Updateable(locOld).UpdateColumns(l => new { l.N_CURRENT_NUM, l.T_MODIFY }).ExecuteCommand() <= 0) {
                    if (old.Location != null && db.Updateable(old.Location).UpdateColumns(l => new { l.N_CURRENT_NUM, l.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"更新[旧货位|容器数量]失败！" + LogObject(locOld));
                        return NewSimpleResult(500, preLog + $"更新[旧货位|当前容器数量]失败!货位='{old.Location.S_CODE}',数量=>{old.Location.N_CURRENT_NUM}");
                    }

                    if (db.Insertable(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"插入[货位容器关系]失败：" + LogObject(locCntrRel));
                        return NewSimpleResult(500, preLog + $"插入[货位容器关系]失败:" + LogObject(locCntrRel));
                    }

                    // 更新[起点/终点]锁状态,创建任务
                    if (db.Updateable(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();
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败！起点='{startLoc.S_CODE}'，锁状态=>'出库锁'");
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败!起点='{startLoc.S_CODE}',锁状态=>'出库锁'");
                    }

                    if (db.Updateable(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, preLog + $"更新[终点货位锁状态]失败！终点='{endLoc.S_CODE}'，锁状态=>'入库锁'");
                        return NewSimpleResult(500, preLog + $"更新[终点货位锁状态]失败!终点='{endLoc.S_CODE}',锁状态=>'入库锁'");
                    }

                    if (db.Insertable(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                    }

                    // 提交数据库更改
                    tran.CommitTran();
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                }
            }
            catch (Exception ex) {
                return NewSimpleResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewSimpleResult(ex, preLog);
            }
        }

@@ -311,41 +292,41 @@
        public static SimpleResult EmptyOnlinePallet(EmptyOnlinePalletInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var taskInfo = ETask.K空托上线出库.Info();
            const string preLog = "API：空托上线出库：";
            const string preLog = "API:空托上线出库:";
            const string cntrType = "托盘";

            try {
                // 查询容器表：容器类型字段
                // 查询容器表:容器类型字段
                var cntr = db.Queryable<TN_Container>().Where(c => c.S_CODE == model.CntId).First();
                if (cntr == null) {
                    return NewSimpleResult(1, $"容器'{model.CntId}'在[容器表]中不存在，请在前台页面中维护！");
                    return NewSimpleResult(1, $"容器'{model.CntId}'在[容器表]中不存在,请在前台页面中维护!");
                }
                if (cntr.S_TYPE != cntrType) {
                    return NewSimpleResult(2, preLog + $"容器'{model.CntId}'在[容器表]中的类型是'{cntr.S_TYPE}，不是'{cntrType}'！");
                    return NewSimpleResult(2, preLog + $"容器'{model.CntId}'在[容器表]中的类型是'{cntr.S_TYPE},不是'{cntrType}'!");
                }

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

                    needUpdateContainer = true;
                    cntr.S_SPEC = model.ItemCode;
                    LogHelper.Info($"容器'{model.CntId}'在[容器表]中[规格(物料编码)]为空，将物料编码'{model.ItemCode}'写入容器的规格");
                    LogHelper.Info($"容器'{model.CntId}'在[容器表]中[规格(物料编码)]为空,将物料编码'{model.ItemCode}'写入容器的规格");
                }
                else if (cntr.S_SPEC != model.ItemCode) {
                    return NewSimpleResult(3, $"容器'{model.CntId}'已经与物料类型'{cntr.S_SPEC}'绑定，无法用于装载物料'{model.ItemCode}'！");
                    return NewSimpleResult(3, $"容器'{model.CntId}'已经与物料类型'{cntr.S_SPEC}'绑定,无法用于装载物料'{model.ItemCode}'!");
                }

                var startLoc = db.Queryable<TN_Location>().LeftJoin<TN_Loc_Container>((l, c) => l.S_CODE == c.S_LOC_CODE).Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y").Where((l, c) => taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 1 && c.S_CNTR_CODE == model.CntId && c.S_CNTR_TYPE == cntrType).First();
                if (startLoc == null) {
                    return NewSimpleResult(3, preLog + $"没有找到合适的起点货位！要求：锁状态='无'；当前容器数量=1；所在库区={LogObject(taskInfo.StartAreas)}，绑定容器编码='{model.CntId}'，绑定容器类型='{cntrType}'");
                    return NewSimpleResult(3, preLog + $"没有找到合适的起点货位!要求:锁状态='无';当前容器数量=1;所在库区={LogObject(taskInfo.StartAreas)},绑定容器编码='{model.CntId}',绑定容器类型='{cntrType}'");
                }

                // 查询终点货位
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y").Where(l => taskInfo.EndAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                if (endLoc == null) {
                    return NewSimpleResult(5, preLog + $"没有找到合适的终点货位！要求：锁状态='无'；当前容器数量=0；所在库区={LogObject(taskInfo.EndAreas)}");
                    return NewSimpleResult(5, preLog + $"没有找到合适的终点货位!要求:锁状态='无';当前容器数量=0;所在库区={LogObject(taskInfo.EndAreas)}");
                }

                WCSHelper.LockStartLoc(ref startLoc);
@@ -357,30 +338,30 @@

                using (var tran = db.Ado.UseTran()) {
                    if (needUpdateContainer && db.Updateable(cntr).UpdateColumns(c => new { c.S_SPEC, c.S_SOURCE, c.T_MODIFY }).ExecuteCommand() <= 0) {
                        return NewSimpleResult(500, preLog + $"更新[容器表]失败！数据：{LogObject(cntr)}");
                        return NewSimpleResult(500, preLog + $"更新[容器表]失败!数据:{LogObject(cntr)}");
                    }

                    // 更新[起点/终点]锁状态,创建任务
                    if (db.Updateable(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();
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败！起点='{startLoc.S_CODE}'，锁状态=>'出库锁'");
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败!起点='{startLoc.S_CODE}',锁状态=>'出库锁'");
                    }

                    if (db.Updateable(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, preLog + $"更新[终点货位锁状态]失败！终点='{endLoc.S_CODE}'，锁状态=>'入库锁'");
                        return NewSimpleResult(500, preLog + $"更新[终点货位锁状态]失败!终点='{endLoc.S_CODE}',锁状态=>'入库锁'");
                    }

                    if (db.Insertable(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                    }

                    // 提交数据库更改
                    tran.CommitTran();
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                }
            }
            catch (Exception ex) {
                return NewSimpleResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewSimpleResult(ex, preLog);
            }
        }

@@ -392,30 +373,27 @@
        public static SimpleResult EmptyOnlineGoodpack(EmptyOnlineGoodpackInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var taskInfo = ETask.K空箱上线出库.Info();
            const string preLog = "API：空箱上线出库：";
            const string preLog = "API:空箱上线出库:";
            const string cntrType = "好运箱";

            try {
                var cntr = db.Queryable<TN_Container>()
                    .Where(c => c.S_CODE == model.CntId)
                    .First();

                var cntr = db.Queryable<TN_Container>().Where(c => c.S_CODE == model.CntId).First();
                if (cntr == null) {
                    return NewSimpleResult(1, preLog + $"容器'{model.CntId}'在[容器表]中不存在，请在前台页面中维护！");
                    return NewSimpleResult(1, preLog + $"容器'{model.CntId}'在[容器表]中不存在,请在前台页面中维护!");
                }
                if (cntr.S_TYPE != cntrType) {
                    return NewSimpleResult(2, preLog + $"容器'{model.CntId}'在[容器表]中的类型='{cntr.S_TYPE}'，不是'{cntrType}'！");
                    return NewSimpleResult(2, preLog + $"容器'{model.CntId}'在[容器表]中的类型='{cntr.S_TYPE}',不是'{cntrType}'!");
                }

                var startLoc = db.Queryable<TN_Location>().LeftJoin<TN_Loc_Container>((l, c) => l.S_CODE == c.S_LOC_CODE).Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y").Where((l, c) => taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 1 && c.S_CNTR_CODE == model.CntId && c.S_CNTR_TYPE == cntrType).First();
                if (startLoc == null) {
                    return NewSimpleResult(2, preLog + $"没有找到合适的起点货位！要求：锁状态='无'，当前容器数量=1，所在库区={LogObject(taskInfo.StartAreas)}，绑定容器编码='{model.CntId}'，绑定容器类型='{cntrType}'");
                    return NewSimpleResult(2, preLog + $"没有找到合适的起点货位!要求:锁状态='无',当前容器数量=1,所在库区={LogObject(taskInfo.StartAreas)},绑定容器编码='{model.CntId}',绑定容器类型='{cntrType}'");
                }

                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => taskInfo.EndAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                if (endLoc == null) {
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位！要求：锁状态='无'，当前容器数量=0，所在库区={LogObject(taskInfo.EndAreas)}");
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位!要求:锁状态='无',当前容器数量=0,所在库区={LogObject(taskInfo.EndAreas)}");
                }

                WCSHelper.LockStartLoc(ref startLoc);
@@ -423,27 +401,27 @@
                var task = WCSHelper.BuildTask(startLoc, endLoc, model.CntId, taskInfo.TaskName);
                
                using (var tran = db.Ado.UseTran()) {
                    // 更新[起点/终点]锁状态,创建任务
                    if (db.Updateable(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();
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败！起点='{startLoc.S_CODE}'，锁状态=>'出库锁'");
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败!起点='{startLoc.S_CODE}',锁状态=>'出库锁'");
                    }

                    if (db.Updateable(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, preLog + $"更新[终点货位锁状态]失败！终点='{endLoc.S_CODE}'，锁状态=>'入库锁'");
                        return NewSimpleResult(500, preLog + $"更新[终点货位锁状态]失败!终点='{endLoc.S_CODE}',锁状态=>'入库锁'");
                    }

                    if (db.Insertable(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                    }

                    // 提交数据库更改
                    tran.CommitTran();
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                }
            }
            catch (Exception ex) {
                return NewSimpleResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewSimpleResult(ex, preLog);
            }
        }

@@ -455,32 +433,29 @@
        public static SimpleResult QualifiedBack(QualifiedBackInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var taskInfo = ETask.C抽检合格回库.Info();
            const string preLog = "API：抽检合格回库";
            const string preLog = "API:抽检合格回库";

            try {
                var cgDetail = db.Queryable<TN_CG_Detail>()
                    .Where(d => d.S_ITEM_CODE == model.ItemCode && d.S_CNTR_CODE == model.CntrCode).First();
                if (cgDetail == null) {
                    return NewSimpleResult(2, preLog + "没有找到待回库的抽检物料：" + LogObject(model));
                    return NewSimpleResult(2, preLog + "没有找到待回库的抽检物料:" + LogObject(model));
                }

                var locCntrRel = db.Queryable<TN_Loc_Container>()
                    .Where(c => c.S_CNTR_CODE == cgDetail.S_CNTR_CODE).First();
                var locCntrRel = db.Queryable<TN_Loc_Container>().Where(c => c.S_CNTR_CODE == cgDetail.S_CNTR_CODE).First();
                if (locCntrRel == null) {
                    return NewSimpleResult(3, preLog + $"容器{model.CntrCode}在货位容器关系表中不存在");
                }

                var startLoc = db.Queryable<TN_Location>()
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y").Where(l => l.S_CODE == locCntrRel.S_LOC_CODE && taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 1).First();
                var startLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && l.S_CODE == locCntrRel.S_LOC_CODE && taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 1).First();
                if (startLoc == null) {
                    return NewSimpleResult(4, preLog + $"没有找到合适的起点货位！要求：锁状态='无'，当前容器数量=1，所在库区={LogObject(taskInfo.StartAreas)}");
                    return NewSimpleResult(4, preLog + $"没有找到合适的起点货位!要求:锁状态='无',当前容器数量=1,所在库区={LogObject(taskInfo.StartAreas)}");
                }

                var endAreas = locCntrRel.S_CNTR_CODE == "托盘" ? taskInfo.EndAreas_Pallet : taskInfo.EndAreas_Goodpack;
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => endAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && endAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                if (endLoc == null) {
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位！要求：锁状态='无'，当前容器数量=0，所在库区={LogObject(endAreas)}");
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位!要求:锁状态='无',当前容器数量=0,所在库区={LogObject(endAreas)}");
                }

                cgDetail.N_ITEM_STATE = 0;
@@ -496,30 +471,30 @@
                using (var tran = db.Ado.UseTran()) {
                    if (db.Updateable(cgDetail).UpdateColumns(it => new { it.N_ITEM_STATE, it.S_ITEM_STATE, it.T_MODIFY }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"更新[物料明细表]失败！物料号='{cgDetail.S_ITEM_CODE}'，物料状态=>'合格'");
                        return NewSimpleResult(500, preLog + $"更新[物料明细表]失败!物料号='{cgDetail.S_ITEM_CODE}',物料状态=>'合格'");
                    }

                    // 更新[起点/终点]锁状态,创建任务
                    if (db.Updateable(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();
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败！起点='{startLoc.S_CODE}'，锁状态=>'出库锁'");
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败!起点='{startLoc.S_CODE}',锁状态=>'出库锁'");
                    }

                    if (db.Updateable(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, preLog + $"更新[终点货位锁状态]失败！终点='{endLoc.S_CODE}'，锁状态=>'入库锁'");
                        return NewSimpleResult(500, preLog + $"更新[终点货位锁状态]失败!终点='{endLoc.S_CODE}',锁状态=>'入库锁'");
                    }

                    if (db.Insertable(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                    }

                    // 提交数据库更改
                    tran.CommitTran();
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                }
            }
            catch (Exception ex) {
                return NewSimpleResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewSimpleResult(ex, preLog);
            }
        }

@@ -531,34 +506,33 @@
        public static SimpleResult UnqualifiedShift(UnqualifiedShiftInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var taskInfo = ETask.C抽检不合格移库.Info();
            const string preLog = "API：抽检不合格移库：";
            const string preLog = "API:抽检不合格移库:";

            try {
                if (!taskInfo.EndAreas.Contains(model.EndArea)) {
                    return NewSimpleResult(1, preLog + $"终点库区'{model.EndArea}'不满足条件！需要：货区={LogObject(taskInfo.EndAreas)}");
                    return NewSimpleResult(1, preLog + $"终点库区'{model.EndArea}'不满足条件!需要:货区={LogObject(taskInfo.EndAreas)}");
                }

                var cgDetail = db.Queryable<TN_CG_Detail>()
                    .Where(d => d.S_ITEM_CODE == model.ItemCode && d.S_CNTR_CODE == model.CntrCode).First();
                if (cgDetail == null) {
                    return NewSimpleResult(2, preLog + $"没有在[物料明细表]中找到物料！要求：物料编码='{model.ItemCode}'，容器编码='{model.CntrCode}'");
                    return NewSimpleResult(2, preLog + $"没有在[物料明细表]中找到物料!要求:物料编码='{model.ItemCode}',容器编码='{model.CntrCode}'");
                }

                var locCntrRel = db.Queryable<TN_Loc_Container>().Where(c => c.S_CNTR_CODE == cgDetail.S_CNTR_CODE).First();
                if (locCntrRel == null) {
                    return NewSimpleResult(3, preLog + $"在[货位容器关系表]中没有找到容器'{model.CntrCode}'！");
                    return NewSimpleResult(3, preLog + $"在[货位容器关系表]中没有找到容器'{model.CntrCode}'!");
                }

                // 查询起点货位：数量=1
                var startLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y").Where(l => l.S_CODE == locCntrRel.S_LOC_CODE && taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 1).First();
                // 查询起点货位:数量=1
                var startLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && l.S_CODE == locCntrRel.S_LOC_CODE && taskInfo.StartAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 1).First();
                if (startLoc == null) {
                    return NewSimpleResult(1, preLog + $"没有找到起点货位'{locCntrRel.S_LOC_CODE}'！要求：锁状态='无'；当前容器数量=1；所在库区={LogObject(taskInfo.StartAreas)}");
                    return NewSimpleResult(1, preLog + $"没有找到起点货位'{locCntrRel.S_LOC_CODE}'!要求:锁状态='无';当前容器数量=1;所在库区={LogObject(taskInfo.StartAreas)}");
                }

                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.S_AREA_CODE == model.EndArea && l.N_CURRENT_NUM == 0).First();
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && l.S_AREA_CODE == model.EndArea && l.N_CURRENT_NUM == 0).First();
                if (endLoc == null) {
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位！要求：锁状态='无'，当前容器数量=0，所在库区='{model.EndArea}'");
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位!要求:锁状态='无',当前容器数量=0,所在库区='{model.EndArea}'");
                }

                cgDetail.N_ITEM_STATE = 2;
@@ -571,30 +545,30 @@
                using (var tran = db.Ado.UseTran()) {
                    if (db.Updateable(cgDetail).UpdateColumns(it => new { it.N_ITEM_STATE, it.S_ITEM_STATE }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"更新[货品明细表]失败！物料号='{cgDetail}'，物料状态=>'{cgDetail.S_ITEM_STATE}'");
                        return NewSimpleResult(500, preLog + $"更新[货品明细表]失败!物料号='{cgDetail}',物料状态=>'{cgDetail.S_ITEM_STATE}'");
                    }

                    // 更新[起点/终点]锁状态,创建任务
                    if (db.Updateable(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();
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败！起点='{startLoc.S_CODE}'，锁状态=>'出库锁'");
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败!起点='{startLoc.S_CODE}',锁状态=>'出库锁'");
                    }

                    if (db.Updateable(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, preLog + $"更新[终点货位锁状态]失败！终点='{endLoc.S_CODE}'，锁状态=>'入库锁'");
                        return NewSimpleResult(500, preLog + $"更新[终点货位锁状态]失败!终点='{endLoc.S_CODE}',锁状态=>'入库锁'");
                    }

                    if (db.Insertable(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                    }

                    // 提交数据库更改
                    tran.CommitTran();
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                }
            }
            catch (Exception ex) {
                return NewSimpleResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewSimpleResult(ex, preLog);
            }
        }

@@ -606,13 +580,12 @@
        public static SimpleResult RestBack(RestBackInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var taskInfo = ETask.W尾料回库.Info();
            const string preLog = "API：尾料回库：";
            const string preLog = "API:尾料回库:";
            
            try {
                var startLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.S_CODE == model.StartLoc && l.N_CURRENT_NUM == 1).First();
                var startLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && l.S_CODE == model.StartLoc && l.N_CURRENT_NUM == 1).First();
                if (startLoc == null) {
                    return NewSimpleResult(2, $"没有找到起点货位'{model.StartLoc}'！要求：锁状态='无'；当前容器数量=1");
                    return NewSimpleResult(2, $"没有找到起点货位'{model.StartLoc}'!要求:锁状态='无';当前容器数量=1");
                }

                var locCntrRel = db.Queryable<TN_Loc_Container>().Where(c => c.S_LOC_CODE == model.StartLoc).First();
@@ -621,10 +594,9 @@
                }

                var endAreas = locCntrRel.S_CNTR_CODE == "托盘" ? taskInfo.EndAreas_Pallet : taskInfo.EndAreas_Goodpack;
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => endAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                var endLoc = db.Queryable<TN_Location>().Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y" && endAreas.Contains(l.S_AREA_CODE) && l.N_CURRENT_NUM == 0).First();
                if (endLoc == null) {
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位！要求：锁状态='无'，当前容器数量=0，所在库区={LogObject(endAreas)}");
                    return NewSimpleResult(3, preLog + $"没有找到合适的终点货位!要求:锁状态='无',当前容器数量=0,所在库区={LogObject(endAreas)}");
                }

                var cntId = locCntrRel.S_CNTR_CODE;
@@ -636,42 +608,42 @@
                using (var tran = db.Ado.UseTran()) {
                    //if (db.Insertable(locCntrRel).ExecuteCommand() <= 0) {
                    //    tran.RollbackTran();
                    //    return NewSimpleResult(500, preLog + $"插入[容器货位绑定表]失败！数据：{LogObject(locCntrRel)}");
                    //    return NewSimpleResult(500, preLog + $"插入[容器货位绑定表]失败!数据:{LogObject(locCntrRel)}");
                    //}

                    // 更新[起点/终点]锁状态,创建任务
                    if (db.Updateable(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();
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败！起点='{startLoc.S_CODE}'，锁状态=>'出库锁'");
                        return NewSimpleResult(500, preLog + $"更新[起点货位锁状态]失败!起点='{startLoc.S_CODE}',锁状态=>'出库锁'");
                    }

                    if (db.Updateable(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, preLog + $"更新[终点货位锁状态]失败！终点='{endLoc.S_CODE}'，锁状态=>'入库锁'");
                        return NewSimpleResult(500, preLog + $"更新[终点货位锁状态]失败!终点='{endLoc.S_CODE}',锁状态=>'入库锁'");
                    }

                    if (db.Insertable(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                        return NewSimpleResult(500, preLog + $"生成任务'{task.S_TYPE}'失败!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                    }

                    // 提交数据库更改
                    tran.CommitTran();
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功！任务号={task.S_CODE}，容器号={task.S_CNTR_CODE}，起点={task.S_START_LOC}，终点={task.S_END_LOC}");
                    return NewSimpleResult(0, preLog + $"生成任务'{task.S_TYPE}'成功!任务号={task.S_CODE},容器号={task.S_CNTR_CODE},起点={task.S_START_LOC},终点={task.S_END_LOC}");
                }
            }
            catch (Exception ex) {
                return NewSimpleResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewSimpleResult(ex, preLog);
            }
        }

        /// <summary>
        /// 成品胶出库(PDA) 待定，暂时不需要此功能
        /// 成品胶出库(PDA) 待定,暂时不需要此功能
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public static SimpleResult FinishedOutbound(FinishedOutboundInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var taskInfo = ETask.C成品胶出库.Info();
            const string preLog = "API：成品胶出库：";
            const string preLog = "API:成品胶出库:";

            try {
                var orderNo = GenerateOrderNo("出库单号", "CKD");
@@ -706,12 +678,12 @@
                using (var tran = db.Ado.UseTran()) {
                    if (db.Insertable(order).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(2, preLog + "生成出库单失败：" + LogObject(order));
                        return NewSimpleResult(2, preLog + "生成出库单失败:" + LogObject(order));
                    }

                    if (db.Insertable(detailList).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(4, preLog + "生成出库单明细失败：" + LogObject(detailList));
                        return NewSimpleResult(4, preLog + "生成出库单明细失败:" + LogObject(detailList));
                    }

                    tran.CommitTran();
@@ -720,7 +692,7 @@
                return NewSimpleResult(0, preLog + "生成出库单成功");
            }
            catch (Exception ex) {
                return NewSimpleResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewSimpleResult(ex, preLog);
            }
        }

@@ -731,7 +703,7 @@
        public static SimpleResult FinishedOutboundForce(FinishedOutboundInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var taskInfo = ETask.C成品胶出库.Info();
            const string preLog = "API：成品胶出库：";
            const string preLog = "API:成品胶出库:";

            try {
                var orderNo = GenerateOrderNo("出库单号", "CKD");
@@ -766,12 +738,12 @@
                using (var tran = db.Ado.UseTran()) {
                    if (db.Insertable(order).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(2, preLog + "生成出库单失败：" + LogObject(order));
                        return NewSimpleResult(2, preLog + "生成出库单失败:" + LogObject(order));
                    }

                    if (db.Insertable(detailList).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewSimpleResult(4, preLog + "生成出库单明细失败：" + LogObject(detailList));
                        return NewSimpleResult(4, preLog + "生成出库单明细失败:" + LogObject(detailList));
                    }

                    tran.CommitTran();
@@ -780,7 +752,7 @@
                return NewSimpleResult(0, preLog + "生成出库单成功");
            }
            catch (Exception ex) {
                return NewSimpleResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewSimpleResult(ex, preLog);
            }
        }

@@ -799,13 +771,13 @@
                    return result;
                }

                // NOTE 根据总量选detail时，是否需要考虑货位的高低？
                // NOTE 根据总量选detail时,是否需要考虑货位的高低？

                var sortedMaterials = new List<TN_CG_Detail>();

                var cntrTypeList = new List<string>();
                if (cntrType == "") {
                    cntrTypeList = new List<string> { "托盘", "好运箱" }; // 不指定托盘类型，二者均可
                    cntrTypeList = new List<string> { "托盘", "好运箱" }; // 不指定托盘类型,二者均可
                }
                else {
                    cntrTypeList.Add(cntrType);
@@ -863,94 +835,94 @@
        }

        /// <summary>
        /// 博实物料信息下发同步（只针对好运箱）
        /// 博实物料信息下发同步 (只针对好运箱) 
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public static MesResult CgInfoSync(CgInfoSyncInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            const string preLog = "API：博实下发物料信息：";
            const string preLog = "API:博实下发物料信息:";
            const string cntrType = "好运箱";

            try {
                if (string.IsNullOrEmpty(model.ItemCode)) {
                    return NewMesResult(400, preLog + $"物料编码'{model.ItemCode}'不能为空！");
                    return NewMesResult(400, preLog + $"物料编码'{model.ItemCode}'不能为空!");
                }
                if (string.IsNullOrEmpty(model.CntrCode)) {
                    return NewMesResult(400, preLog + $"容器编码'{model.CntrCode}'不能为空！");
                    return NewMesResult(400, preLog + $"容器编码'{model.CntrCode}'不能为空!");
                }
                if (string.IsNullOrEmpty(model.BatchNo)) {
                    return NewMesResult(400, preLog + $"批次号'{model.BatchNo}'不能为空！");
                    return NewMesResult(400, preLog + $"批次号'{model.BatchNo}'不能为空!");
                }
                if (model.ItemNum <= 0) {
                    return NewMesResult(400, preLog + $"物料数量'{model.ItemNum}'不合法！要求：物料数量＞0");
                    return NewMesResult(400, preLog + $"物料数量'{model.ItemNum}'不合法!要求:物料数量＞0");
                }

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

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

                // 将下发的信息先存储到CG表中（此时托盘没有与产线处的货位绑定）
                // 将下发的信息先存储到CG表中 (此时托盘没有与产线处的货位绑定) 
                var detail = new TN_CG_Detail {
                    S_ITEM_CODE = model.ItemCode, // NOT NULL
                    S_ITEM_NAME = model.ItemName, 
                    S_CNTR_CODE = model.CntrCode, // NOT NULL 料箱编号（待定，现在暂时设定为博实下发）
                    S_CNTR_CODE = model.CntrCode, // NOT NULL 料箱编号 (待定,现在暂时设定为博实下发) 
                    S_BATCH_NO = model.BatchNo,   // NOT NULL
                    S_STANDARD = model.Standard,
                    S_NET_WEIGHT = model.NetWeight,
                    S_QUALITY_GRADE = model.QualityGrade,
                };

                // 产线号的逻辑待定，现在设定为博实下发产线号，看后续需求变更
                // 好运箱起点为产线货位，人工将好运箱从产线上取下，搬运到满好运箱操作区
                // 产线号的逻辑待定,现在设定为博实下发产线号,看后续需求变更
                // 好运箱起点为产线货位,人工将好运箱从产线上取下,搬运到满好运箱操作区
                //var startLocCode = "";
                //if (model.ProdLineId.Trim() == "3") {
                //    startLocCode = "";
                //}

                //if (model.ProdLineId.Trim() != "3" || model.ProdLineId.Trim() != "4") {
                //    info = $"不合法的产线号{model.ProdLineId}：好运箱产线号必须为 3 或 4";
                //    info = $"不合法的产线号{model.ProdLineId}:好运箱产线号必须为 3 或 4";
                //    LogHelper.Info(info);
                //    return NewMesResult(2, info);
                //}

                if (db.Insertable(detail).ExecuteCommand() <= 0) {
                    return NewMesResult(500, preLog + $"插入[物料明细表]失败！数据：{LogObject(detail)}");
                    return NewMesResult(500, preLog + $"插入[物料明细表]失败!数据:{LogObject(detail)}");
                }

                return NewMesResult(500, preLog + $"插入[物料明细表]成功！数据：{LogObject(detail)}");
                return NewMesResult(500, preLog + $"插入[物料明细表]成功!数据:{LogObject(detail)}");
            }
            catch (Exception ex) {
                return NewMesResult(-1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewMesResult(-1, preLog + $"发生了异常:{ex.Message}\n\n{ex.StackTrace}\n");
            }
        }

        public static ErpResult ErpSendOutboundPlan(ErpSendOutboundPlanInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var orderNo = GenerateOrderNo("出库单号", "CKD");
            const string preLog = "API：ERP下发出库计划单：";
            const string preLog = "API:ERP下发出库计划单:";
            try {
                if (model.pzjs <= 0) {
                    return NewErpResult(400, preLog + $"物料数量(pzjs)'{model.pzjs}'不合法！要求：物料数量＞0");
                    return NewErpResult(400, preLog + $"物料数量(pzjs)'{model.pzjs}'不合法!要求:物料数量＞0");
                }

                var outboundPlan = db.Queryable<TN_Outbound_Plan>()
                    .Where(p => p.JHDH == model.jhdh).First();
                if (outboundPlan != null) {
                    return NewErpResult(1, preLog + $"计划单号'{model.jhdh}'已在[出库计划单]中存在！");
                    return NewErpResult(1, preLog + $"计划单号'{model.jhdh}'已在[出库计划单]中存在!");
                }

                outboundPlan = new TN_Outbound_Plan {
                    JHDH = model.jhdh, // 计划单号（唯一标识）
                    CKZT = model.ckzt, // 出库状态（需要返回）
                    JHDH = model.jhdh, // 计划单号 (唯一标识) 
                    CKZT = model.ckzt, // 出库状态 (需要返回) 
                    JHLB = model.jhlb, // 计划类别
                    CKDH = model.ckdh, // 参考单号
                    CPH = model.cph, // 车牌号
@@ -961,9 +933,9 @@
                    CPLB = model.cplb, // 产品类别
                    CPLBMX = model.cplbmx, // 产品类别明细
                    PP = model.pp, // 品牌
                    DJ = model.dj, // 等级（需要返回）
                    DJ = model.dj, // 等级 (需要返回) 
                    GH = model.gh, // 罐号
                    PH = model.ph, // 批号（需要返回）
                    PH = model.ph, // 批号 (需要返回) 
                    BZLX = model.bzlx, // 包装类型
                    PZDH = model.pzdh, // 派装单号
                    PZD_DW = model.pzd_dw, // 派装单单位
@@ -976,15 +948,15 @@
                    PZ_ZFRQ = model.pz_zfrq, // 派装作废日期
                    PZ_BZ = model.pz_bz, // 派装备注
                    CKDBH = model.ckdbh, // 出库单编号
                    SFJS = model.sfjs, // 实发件数（需要返回）
                    SFSL = model.sfsl, // 实发数量（需要返回）
                    SFCS = model.sfcs, // 实发车数（需要返回）
                    ZCSJ = model.zcsj, // 装车时间（需要返回）
                    JLDW = model.jldw, // 计量单位（需要返回）
                    FHRQ = model.fhrq, // 发货日期（需要返回）
                    CKDM = model.ckdm, // 仓库代码（需要返回）
                    FHR = model.fhr, // 发货人（需要返回）
                    CZYDM = model.czydm, // 操作员（需要返回）
                    SFJS = model.sfjs, // 实发件数 (需要返回) 
                    SFSL = model.sfsl, // 实发数量 (需要返回) 
                    SFCS = model.sfcs, // 实发车数 (需要返回) 
                    ZCSJ = model.zcsj, // 装车时间 (需要返回) 
                    JLDW = model.jldw, // 计量单位 (需要返回) 
                    FHRQ = model.fhrq, // 发货日期 (需要返回) 
                    CKDM = model.ckdm, // 仓库代码 (需要返回) 
                    FHR = model.fhr, // 发货人 (需要返回) 
                    CZYDM = model.czydm, // 操作员 (需要返回) 
                    SHR_USERNAME = model.shr_username, // 审核人
                    SHRQ = model.shrq, // 审核日期
                    ZFBJ = model.zfbj, // 作废标记
@@ -993,14 +965,14 @@
                    SHDW = model.shdw, // 收货单位
                    YSDW = model.ysdw, // 运输单位
                    LXR = model.lxr, // 联系人
                    RY_ZXG = model.ry_zxg, // 装卸工（需要返回）
                    RY_CCSJ = model.ry_ccsj, // 叉车司机（需要返回）
                    RY_ZXG = model.ry_zxg, // 装卸工 (需要返回) 
                    RY_CCSJ = model.ry_ccsj, // 叉车司机 (需要返回) 
                    ERPHX_JHDH = model.erphx_jhdh, // erp交货单号
                    ERPHX_WLBM = model.erphx_wlbm, // erp物料编码
                    ERPHX_WLMC = model.erphx_wlmc, // erp物料名称
                    ERPHX_CJRQ = model.erphx_cjrq, // erp创建日期
                    HW = model.hw, // 货位（需要返回）
                    HWZT = model.hwzt // 货位状态（需要返回）
                    HW = model.hw, // 货位 (需要返回) 
                    HWZT = model.hwzt // 货位状态 (需要返回) 
                };

                //var cgDetailList = SelectCgByTotalQty(
@@ -1015,10 +987,9 @@
                //    return NewErpResult(3, info);
                //}

                var cgDetail = db.Queryable<TN_CG_Detail>()
                    .Where(d => d.S_ITEM_CODE == model.cpdm && d.N_ITEM_NUM >= model.pzjs).First();
                var cgDetail = db.Queryable<TN_CG_Detail>().Where(d => d.S_ITEM_CODE == model.cpdm && d.N_ITEM_NUM >= model.pzjs).First();
                if (cgDetail == null ) {
                    return NewErpResult(2, preLog + $"在[货品明细表]中没有找到合适的物料！要求：物料编码='{model.cpdm}'，物料数量>={model.pzjs}");
                    return NewErpResult(2, preLog + $"在[货品明细表]中没有找到合适的物料!要求:物料编码='{model.cpdm}',物料数量>={model.pzjs}");
                }

                var order = new TN_Outbound_Order {
@@ -1063,25 +1034,25 @@
                using (var tran = db.Ado.UseTran()) {
                    if (db.Insertable(order).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewErpResult(500, preLog + $"生成[出库单]失败！数据：{LogObject(order)}");
                        return NewErpResult(500, preLog + $"生成[出库单]失败!数据:{LogObject(order)}");
                    }

                    if (db.Insertable(detailList).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewErpResult(500, preLog + $"生成[出库单明细]失败！数据：{LogObject(detailList)}");
                        return NewErpResult(500, preLog + $"生成[出库单明细]失败!数据:{LogObject(detailList)}");
                    }

                    if (db.Insertable(outboundPlan).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return NewErpResult(500, preLog + $"生成[出库单计划记录表]失败！数据：{LogObject(outboundPlan)}");
                        return NewErpResult(500, preLog + $"生成[出库单计划记录表]失败!数据:{LogObject(outboundPlan)}");
                    }

                    tran.CommitTran();
                    return NewErpResult(0, preLog + $"生成[出库单]成功！出库单：{LogObject(order)}\n出库单明细：{LogObject(detail)}");
                    return NewErpResult(0, preLog + $"生成[出库单]成功!出库单:{LogObject(order)}\n出库单明细:{LogObject(detail)}");
                }
            }
            catch (Exception ex) {
                return NewErpResult(1, preLog + $"发生了异常：{ex.Message}\n{ex.StackTrace}");
                return NewErpResult(1, preLog + $"发生了异常:{ex.Message}\n\n{ex.StackTrace}\n");
            }
        }