完善单容器多物料场景的优化重构, 优化ERP回报信息的处理

kazelee

4 天以前 fbb7c2253c86d58583d7e3b0a8a44d0342c43c73

 api/ApiHelper.cs

@@ -18,130 +18,6 @@

namespace HH.WCS.Mobox3.AnGang.api {
    public class ApiHelper {
        /// <summary>
        /// 产品入库(PDA)
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResult Inbound(InboundInfo model) {
            var taskName = TaskName.产品入库;
            var db = new SqlHelper<object>().GetInstance();

            var startAreas = Settings.Areas[AreaIndex.Q取货区];

            try {
                // 起点位置必须：为空、无锁、启用、属于收发区域
                var startLoc = db.Queryable<TN_Location>()
                    .Where(a => a.S_CODE == model.StartLoc)
                    .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y")
                    .Where(a => a.N_CURRENT_NUM == 0)
                    .Where(a => startAreas.Contains(a.S_AREA_CODE))
                    .First();

                if (startLoc == null) {
                    return BuildSimpleResult(1, $"起点位置{model.StartLoc}不存在或不满足要求：(1)没有锁状态 (2)属于取放货区");
                }

                //var locCntrRelOld = db.Queryable<TN_Loc_Container>()
                //    .Where(c => c.S_LOC_CODE == model.StartLoc).First();

                //// 产品入库：假定用户不会将新入库物料，放到已有物料的收发货区入库
                //// 新产品入库时，如果存在旧的货位绑定数据（出库遗留项目）直接删除
                //TN_CG_Detail cgDetailOld = null;
                //if (locCntrRelOld != null) {
                //    cgDetailOld = db.Queryable<TN_CG_Detail>()
                //        .Where(d => d.S_CNTR_CODE == locCntrRelOld.S_CNTR_CODE).First();
                //}

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

                // 首次入库：没有绑定信息，先将起点位置与容器绑定，容器与物料绑定
                var locCntrRel = new TN_Loc_Container() {
                    S_LOC_CODE = startLoc.S_CODE,
                    S_CNTR_CODE = cntId,
                };

                var cgDetail = new TN_CG_Detail() {
                    S_ITEM_CODE = cgId,
                    S_CNTR_CODE = cntId,
                    S_LOC_CODE = startLoc.S_CODE, // ADD：补充针对PDA分拣
                };

                startLoc.N_CURRENT_NUM = 1;

                var endLocCode = "0"; // 假的默认终点地址

                // 指定货位排号（不能为空、空字符串或空格）
                if (model.Row != null && model.Row.Trim() != "") {
                    endLocCode = model.Row; // 用排号字符串当做假地址
                    if (!int.TryParse(model.Row.Trim(), out int row)) {
                        return BuildSimpleResult(2, $"{model.Row} 不合法：无法转成整数类型");
                    }
                    // 货架排号只能是 0 - 8（111-118）
                    if (row <= 110 || row > 118) {
                        return BuildSimpleResult(2, $"货架号 {model.Row} 必须是111-118之间的整数");
                    }
                }

                var task = WCSHelper.BuildInboundTask(startLoc, endLocCode, cntId);
                LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁

                // 无论是否选择终点货架，都等到称重之后再计算终点货位
                using (var tran = db.Ado.UseTran()) {
                    //if (locCntrRelOld != null) {
                    //    if (db.Deleteable<TN_Loc_Container>(locCntrRelOld).ExecuteCommand() <= 0) {
                    //        tran.RollbackTran();
                    //        return BuildSimpleResult(500,
                    //            $"删除货位容器关系表失败：货位{locCntrRelOld.S_LOC_CODE}，容器{locCntrRelOld.S_CNTR_CODE}");
                    //    }
                    //}
                    //if (cgDetailOld != null) {
                    //    if (db.Deleteable<TN_CG_Detail>(cgDetailOld).ExecuteCommand() <= 0) {
                    //        tran.RollbackTran();
                    //        return BuildSimpleResult(500,
                    //            $"删除旧容器货品明细表失败：容器{cgDetailOld.S_CNTR_CODE}，物料{cgDetailOld.S_ITEM_CODE}");
                    //    }
                    //}

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"插入货位容器关系表失败：货位{locCntrRel.S_LOC_CODE}，容器{locCntrRel.S_CNTR_CODE}");
                    }

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

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

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

                    tran.CommitTran();
                    return BuildSimpleResult(0,
                        $"生成任务 {taskName} 成功：容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货架 {endLocCode} ，终点货位未指定");
                }
            }
            catch (Exception ex) {
                return BuildSimpleResult(1, $"发生了异常：{ex.Message}");
            }
        }
        
        public static SimpleResult InboundData(InboundDataInfo model) {
            var taskName = TaskName.产品入库;
            var db = new SqlHelper<object>().GetInstance();
@@ -161,22 +37,7 @@
                    return BuildSimpleResult(1, $"起点位置{model.StartLoc}不存在或不满足要求：(1)没有锁状态 (2)属于取放货区");
                }

                //var locCntrRelOld = db.Queryable<TN_Loc_Container>()
                //    .Where(c => c.S_LOC_CODE == model.StartLoc).First();

                //// 产品入库：假定用户不会将新入库物料，放到已有物料的收发货区入库
                //// 新产品入库时，如果存在旧的货位绑定数据（出库遗留项目）直接删除
                //TN_CG_Detail cgDetailOld = null;
                //if (locCntrRelOld != null) {
                //    cgDetailOld = db.Queryable<TN_CG_Detail>()
                //        .Where(d => d.S_CNTR_CODE == locCntrRelOld.S_CNTR_CODE).First();
                //}

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

                // 首次入库：绑定信息，先将起点位置与容器绑定，容器与物料绑定
@@ -189,8 +50,16 @@
                var cgDetail = new TN_CG_Detail() {
                    S_ITEM_CODE = cgId,
                    S_CNTR_CODE = cntId,
                    //S_ITEM_NAME = model.ItemName,
                    S_LOC_CODE = startLoc.S_CODE, // ADD：补充针对PDA分拣
                    N_LOCK_STATE = locCntrRel.N_LOCK_STATE,
                    S_ITEM_SHORT_DESC = string.IsNullOrEmpty(model.ItemShortDesc) ? "" : model.ItemShortDesc,
                    S_ITEM_NAME = string.IsNullOrEmpty(model.ItemName) ? "" : model.ItemName,
                    F_QTY = model.ItemCount, // 0f by default
                };

                var cntr = new TN_Container() {
                    S_CODE = cntId,
                    N_DETAIL_COUNT = 1
                };

                startLoc.N_CURRENT_NUM = 1;
@@ -214,20 +83,11 @@

                // 无论是否选择终点货架，都等到称重之后再计算终点货位
                using (var tran = db.Ado.UseTran()) {
                    //if (locCntrRelOld != null) {
                    //    if (db.Deleteable<TN_Loc_Container>(locCntrRelOld).ExecuteCommand() <= 0) {
                    //        tran.RollbackTran();
                    //        return BuildSimpleResult(500,
                    //            $"删除货位容器关系表失败：货位{locCntrRelOld.S_LOC_CODE}，容器{locCntrRelOld.S_CNTR_CODE}");
                    //    }
                    //}
                    //if (cgDetailOld != null) {
                    //    if (db.Deleteable<TN_CG_Detail>(cgDetailOld).ExecuteCommand() <= 0) {
                    //        tran.RollbackTran();
                    //        return BuildSimpleResult(500,
                    //            $"删除旧容器货品明细表失败：容器{cgDetailOld.S_CNTR_CODE}，物料{cgDetailOld.S_ITEM_CODE}");
                    //    }
                    //}
                    if (db.Insertable<TN_Container>(cntr).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"插入容器表关系失败: 容器{cntr.S_CODE}, 明细条数={cntr.N_DETAIL_COUNT}");
                    }

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
@@ -276,87 +136,192 @@
        }

        /// <summary>
        /// 兼容Inbound和PartInbound的功能，备用（问题：出库后无法自动清数据，导致入库后回库）
        /// 指定货位入库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public static SimpleResult InboundTwoWays(InboundInfo model) {
            var taskName = TaskName.产品入库;
        internal static SimpleResult InboundLoc(InboundLocInfo model) {
            var taskName = TaskName.指定货位入库;
            var db = new SqlHelper<object>().GetInstance();

            var startAreas = Settings.Areas[AreaIndex.Q取货区];
            var endAreas = Settings.Areas[AreaIndex.H货架区];

            try {
                // 起点位置必须：为空、无锁、启用、属于收发区域
                // 起点位置：取放货区（有货物、没有锁、已启用）
                var startLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.startLoc && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && startAreas.Contains(a.S_AREA_CODE));
                if (startLoc == null) {
                    return BuildSimpleResult(1, $"起点位置{model.startLoc}不存在或不满足要求：(1)没有锁状态 (2)属于取放货区");
                }

                //var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
                //if (locCntrRel == null) {
                //    return BuildSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
                //}

                var cntId = GenerateNo("容器号", "CN");
                //var cgId = GenerateNo("物料号", "CG");
                var cgId = string.IsNullOrEmpty(model.ItemCode) ? GenerateNo("物料号", "CG") : model.ItemCode;

                // 首次入库：绑定信息，先将起点位置与容器绑定，容器与物料绑定
                var locCntrRel = new TN_Loc_Container() {
                    S_LOC_CODE = startLoc.S_CODE,
                    S_CNTR_CODE = cntId,
                    N_LOCK_STATE = string.IsNullOrEmpty(model.ItemCode) ? 0 : 1,
                };

                var cgDetail = new TN_CG_Detail() {
                    S_ITEM_CODE = cgId,
                    S_CNTR_CODE = cntId,
                    //S_ITEM_NAME = model.ItemName,
                    S_LOC_CODE = startLoc.S_CODE, // ADD：补充针对PDA分拣
                    N_LOCK_STATE = locCntrRel.N_LOCK_STATE,
                    S_ITEM_SHORT_DESC = string.IsNullOrEmpty(model.ItemShortDesc) ? "" : model.ItemShortDesc,
                    S_ITEM_NAME = string.IsNullOrEmpty(model.ItemName) ? "" : model.ItemName,
                    F_QTY = model.ItemCount, // 0f by default
                };

                var cntr = new TN_Container() {
                    S_CODE = cntId,
                    N_DETAIL_COUNT = 1
                };

                startLoc.N_CURRENT_NUM = 1;

                // 终点位置：货架（没有货物，没有锁）
                var endLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.endLoc && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && endAreas.Contains(a.S_AREA_CODE));
                if (endLoc == null) {
                    return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                }

                //var cntId = locCntrRel.S_CNTR_CODE;
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntId, taskName);
                LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
                LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁

                using (var tran = db.Ado.UseTran()) {
                    if (db.Insertable<TN_Container>(cntr).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"插入容器表关系失败: 容器{cntr.S_CODE}, 明细条数={cntr.N_DETAIL_COUNT}");
                    }

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"插入货位容器关系表失败：货位{locCntrRel.S_LOC_CODE}，容器{locCntrRel.S_CNTR_CODE}");
                    }

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

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

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

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

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

        public static async Task<SimpleResult> AddCgDetail(AddCgDetailInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            try {
                await Task.Delay(500); // 等待 Mobox 添加主表完成

                var startLoc = db.Queryable<TN_Location>()
                    .Where(a => a.S_CODE == model.StartLoc)
                    .Where(a => a.S_CODE == model.LocCode)
                    .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y")
                    //.Where(a => a.N_CURRENT_NUM == 0)
                    .Where(a => startAreas.Contains(a.S_AREA_CODE))
                    .First();

                if (startLoc == null) {
                    return BuildSimpleResult(1, $"起点位置{model.StartLoc}不存在或不满足要求：(1)没有锁状态 (2)属于取放货区");
                    return BuildSimpleResult(1, $"货位没有找到!");
                }

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

                var locCntrRel = db.Queryable<TN_Loc_Container>()
                    .Where(c => c.S_LOC_CODE == model.StartLoc).First();

                // 只有首次入库（当前托盘未绑定在起点货位）时cgDetail设置值，并插入
                // 否则，cgDetail为空，代表是回库作业（此前有绑定过起点）
                TN_CG_Detail cgDetail = null;
                if (locCntrRel == null) {
                    // 首次入库：没有绑定信息，先将起点位置与容器绑定，容器与物料绑定
                    locCntrRel = new TN_Loc_Container() {
                        S_LOC_CODE = startLoc.S_CODE,
                        S_CNTR_CODE = cntId,
                    };

                    cgDetail = new TN_CG_Detail() {
                        S_ITEM_CODE = cgId,
                        S_CNTR_CODE = cntId,
                    };
                if (startLoc.N_CURRENT_NUM != 0) {
                    return BuildSimpleResult(2, $"当前货位已经有容器!");
                }

                startLoc.N_CURRENT_NUM = 1;

                var endLocCode = "0"; // 假的默认终点地址
                var cntId = GenerateNo("容器号", "CN");

                // 指定货位排号（不能为空、空字符串或空格）
                if (model.Row != null && model.Row.Trim() != "") {
                    endLocCode = model.Row; // 用排号字符串当做假地址
                    if (!int.TryParse(model.Row.Trim(), out int row)) {
                        return BuildSimpleResult(2, $"{model.Row} 不合法：无法转成整数类型");
                    }
                    // 货架排号只能是 0 - 8（111-118）
                    if (row <= 110 || row > 118) {
                        return BuildSimpleResult(2, $"货架号 {model.Row} 必须是111-118之间的整数");
                    }
                var locCntrRel = new TN_Loc_Container() {
                    S_LOC_CODE = model.LocCode,
                    S_CNTR_CODE = cntId,
                    N_LOCK_STATE = string.IsNullOrEmpty(model.ItemCode) ? 0 : 1,
                };

                //var cgDetail = new TN_CG_Detail() {
                //    S_ITEM_CODE = model.ItemCode,
                //    S_CNTR_CODE = model.CntrCode,
                //    S_LOC_CODE = model.LocCode, // ADD：补充针对PDA分拣
                //    N_LOCK_STATE = locCntrRel.N_LOCK_STATE,
                //    S_ITEM_SHORT_DESC = string.IsNullOrEmpty(model.ItemShortDesc) ? "" : model.ItemShortDesc,
                //    S_ITEM_NAME = string.IsNullOrEmpty(model.ItemName) ? "" : model.ItemName,
                //    F_QTY = model.ItemCount, // 0f by default
                //};

                var cgDetail = db.Queryable<TN_CG_Detail>().Where(d => d.S_ITEM_CODE == model.ItemCode && d.S_LOC_CODE == model.LocCode && d.S_CNTR_CODE == "自动生成").First();
                if (cgDetail == null) {
                    return BuildSimpleResult(3, $"Mobox 容器货品明细表未创建成功!");
                }
                cgDetail.S_CNTR_CODE = cntId;

                var task = WCSHelper.BuildInboundTask(startLoc, endLocCode, cntId);
                LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
                var cntr = new TN_Container() {
                    S_CODE = cntId,
                    N_DETAIL_COUNT = 1
                };

                // 无论是否选择终点货架，都等到称重之后再计算终点货位
                using (var tran = db.Ado.UseTran()) {
                    if (cgDetail != null) {
                        if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            return BuildSimpleResult(500,
                                $"插入货位容器关系表失败：货位{locCntrRel.S_LOC_CODE}，容器{locCntrRel.S_CNTR_CODE}");
                        }

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

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"插入货位容器关系表失败：货位{locCntrRel.S_LOC_CODE}，容器{locCntrRel.S_CNTR_CODE}");
                    }

                    if (db.Updateable<TN_CG_Detail>(cgDetail).UpdateColumns(d => new { d.S_CNTR_CODE }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"更新容器货品明细表失败：容器{cgDetail.S_CNTR_CODE}，物料{cgDetail.S_ITEM_CODE}");
                    }

                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
@@ -370,23 +335,15 @@
                        return BuildSimpleResult(500,
                            $"更新起点货位锁状态失败：起点货位{startLoc.S_CODE}");
                    }

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

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


        /// <summary>
        /// PDA选择终点货位
@@ -414,15 +371,15 @@
                    return BuildSimpleResult(3, $"该任务已有终点");
                }

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

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

                var endLoc = new TN_Location();
                if (cgDetail.F_QTY > 2000) {
                if (task.F_WEIGHT > 2000) {
                    // 重量超过2t，报错
                    if (GZRobot.TryGetInteractionInfoId(task.S_CODE, out var id1)) {
                        if (GZRobot.UpdateInteractInfo(new UpdateInteractInfo {
@@ -443,9 +400,9 @@
                        //return BuildSimpleResult(8, $"国自AGV接受终点信息失败");
                    }

                    return BuildSimpleResult(8, $"物料重量{cgDetail.F_QTY}超过2t");
                    return BuildSimpleResult(8, $"物料重量{task.F_WEIGHT}超过2t");
                }
                else if (cgDetail.F_QTY > 1500) {
                else if (task.F_WEIGHT > 1500) {
                    // 重量超过1.5t，需要选择1-2层货架
                    endLoc = db.Queryable<TN_Location>()
                        .Where(a => a.S_CODE == model.EndLoc)
@@ -455,7 +412,7 @@
                        .Where(a => a.N_LAYER <= 2)
                        .First();
                }
                else if (cgDetail.F_QTY > 0) {
                else if (task.F_WEIGHT > 0) {
                    endLoc = db.Queryable<TN_Location>()
                        .Where(a => a.S_CODE == model.EndLoc)
                        .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y")
@@ -466,7 +423,7 @@
                        .First();
                }
                else {
                    return BuildSimpleResult(5, $"物料重量信息不合法：{cgDetail.F_QTY}");
                    return BuildSimpleResult(5, $"物料重量信息不合法：{task.F_WEIGHT}");
                }

                // 没有符合条件的货位
@@ -611,7 +568,7 @@

            try {
                // 起点位置：取放货区（有货物、没有锁、已启用）
                var startLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.startLoc && a.N_CURRENT_NUM == 1 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && startAreas.Contains(a.S_AREA_CODE));
                var startLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.startLoc && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && startAreas.Contains(a.S_AREA_CODE));
                if (startLoc == null) {
                    return BuildSimpleResult(2, $"起点位置 {model.startLoc} 不符合回库条件");
                }
@@ -663,73 +620,54 @@
            }
        }

        

        /// <summary>
        /// 产品部分回库（不指定终点，备用）
        /// 货位容器解绑
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResult PartInboundAuto(PartInboundInfo model) {
            var taskName = TaskName.产品部分回库;
        internal static SimpleResult UnbindLoc(UnbindLocInfo model) {
            var db = new SqlHelper<object>().GetInstance();

            var startAreas = Settings.Areas[AreaIndex.X卸货区];
            var endAreas = Settings.Areas[AreaIndex.H货架区];
            //var endAreas = Settings.Areas[AreaIndex.H货架区];

            try {
                // 起点位置：取放货区（有货物、没有锁、已启用）
                var startLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.startLoc && a.N_CURRENT_NUM == 1 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && startAreas.Contains(a.S_AREA_CODE));
                if (startLoc == null) {
                    return BuildSimpleResult(2, $"起点位置 {model.startLoc} 不符合回库条件");
                    return BuildSimpleResult(1, $"起点位置{model.startLoc}不存在或不满足要求：(1)没有锁状态 (2)属于取货区");
                }

                var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
                if (locCntrRel == null) {
                    return BuildSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
                    return BuildSimpleResult(2, $"当前货位{model.startLoc}没有货位容器绑定关系，无需解绑！");
                }

                // 终点位置：货架（没有货物，没有锁）
                var endLoc = db.Queryable<TN_Location>().First(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && endAreas.Contains(a.S_AREA_CODE));
                if (endLoc == null) {
                    return BuildSimpleResult(4, $"没有找到合适的终点货位");
                var cgDetailList = db.Queryable<TN_CG_Detail>().Where(a => a.S_CNTR_CODE == locCntrRel.S_CNTR_CODE).ToList();
                if (cgDetailList.Count != 0) {
                    return BuildSimpleResult(3, $"当前货位{model.startLoc}容器存放的物料数量不为0，无法解绑！");
                }

                var cntId = locCntrRel.S_CNTR_CODE;
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntId, taskName);
                LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
                LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁
                startLoc.N_CURRENT_NUM = 0;
                startLoc.T_MODIFY = DateTime.Now;

                using (var tran = db.Ado.UseTran()) {
                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE,
                        it.S_LOCK_STATE,
                        it.S_LOCK_OP,
                        it.T_MODIFY
                    }).ExecuteCommand() <= 0) {
                    if (db.Deleteable(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货位 {endLoc.S_CODE}");
                            $"删除货位容器绑定关系失败!" + JsonConvert.SerializeObject(locCntrRel));
                    }

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

                    if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"生成 {taskName} 失败，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                            $"删除货位容器绑定关系失败!" + JsonConvert.SerializeObject(locCntrRel));
                    }

                    tran.CommitTran();
                    return BuildSimpleResult(0,
                        $"生成 {taskName} 成功，容器号 {cntId} ，起点 {startLoc.S_CODE} ，终点货架 {endLoc.S_CODE}");
                    return BuildSimpleResult(0, "解绑容器货品关系成功");
                }
            }
            catch (Exception ex) {
@@ -910,7 +848,6 @@
        }

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

            var db = new SqlHelper<object>().GetInstance();
            try {
@@ -918,24 +855,23 @@
                    return BuildErpResult(400, "不能传入空的数据列表");
                }

                //var info = "";
                //var cgDetailList = new List<TN_CG_Detail>();
                var insetRecordList = new List<TN_Inbound_DataRecord>();
                var deleteRecordOldList = new List<TN_Inbound_DataRecord> ();
                //var errList = new List<TN_Inbound_DataRecord>();
                var insertRecordList = new List<TN_Inbound_DataRecord>();
                //var deleteRecordOldList = new List<TN_Inbound_DataRecord> ();

                foreach (var transaction in model.stockTransactions) {
                    var recordOld = db.Queryable<TN_Inbound_DataRecord>()
                        .Where(r => r.S_LOCATION_CODE == "HJQ-" + transaction.locationCode.Trim()).First();
                    if (recordOld != null) {
                        deleteRecordOldList.Add(recordOld);
                        //errList.Add(recordOld);
                        //continue;
                    //var recordOld = db.Queryable<TN_Inbound_DataRecord>()
                    //    .Where(r => r.S_LOCATION_CODE == transaction.locationCode.Trim()).First();
                    //if (recordOld != null) {
                    //    deleteRecordOldList.Add(recordOld);
                    //}

                    if (!float.TryParse(transaction.inQuantity, out var _) || !float.TryParse(transaction.stockQuantity, out var _)) {
                        return BuildErpResult(400, $"入库数量或库存数量不合法! 请确保字符串的值可以解析为数值! 库存交易明细号='{transaction.stockTransactionId}', 入库数量='{transaction.inQuantity}', 库存数量='{transaction.stockQuantity}'");
                    }

                    // 写入记录表
                    var record = new TN_Inbound_DataRecord {
                        S_LOCATION_CODE = "HJQ-" + transaction.locationCode.Trim(),
                        S_LOCATION_CODE = transaction.locationCode.Trim(),
                        S_STOCK_TRANS = transaction.stockTransactionId,
                        S_ITEM_CODE = transaction.itemCode,
                        S_ITEM_NAME = transaction.itemName,
@@ -950,58 +886,24 @@
                        S_SUPPLIER_NAME = transaction.supplierName,
                        S_INVENTORY_MAN = transaction.inventoryManager
                    };
                    insetRecordList.Add(record);
                    insertRecordList.Add(record);

                    //// 查询对应物料
                    //var cgDetail = db.Queryable<TN_Location, TN_Loc_Container, TN_CG_Detail>
                    //    ((l, c, d) => l.S_CODE == c.S_LOC_CODE && c.S_CNTR_CODE == d.S_CNTR_CODE)
                    //    .Where(l => l.S_CODE == transaction.locationCode)
                    //    .Select((l, c, d) => d)
                    //    .First();

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

                    //cgDetailList.Add(cgDetail);
                }
                
                using (var tran = db.Ado.UseTran()) {
                    if (deleteRecordOldList.Count != 0 && db.Deleteable<TN_Inbound_DataRecord>(deleteRecordOldList).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildErpResult(500, $"删除旧入库记录数据失败：{JsonConvert.SerializeObject(deleteRecordOldList)}");
                    }
                    //if (deleteRecordOldList.Count != 0 && db.Deleteable<TN_Inbound_DataRecord>(deleteRecordOldList).ExecuteCommand() <= 0) {
                    //    tran.RollbackTran();
                    //    return BuildErpResult(500, $"删除旧入库记录数据失败：{JsonConvert.SerializeObject(deleteRecordOldList)}");
                    //}

                    if (db.Insertable<TN_Inbound_DataRecord>(insetRecordList).ExecuteCommand() <= 0) {
                    if (db.Insertable<TN_Inbound_DataRecord>(insertRecordList).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildErpResult(500, $"写入入库记录表失败!");
                    }

                    //if (db.Updateable<TN_CG_Detail>(cgDetailList).ExecuteCommand() <= 0) {
                    //    tran.RollbackTran();
                    //    return BuildErpResult(500, $"更改物料信息失败！待更新物料信息数量={cgDetailList.Count}");
                    //}

                    tran.CommitTran();
                    return BuildErpResult(0, $"写入入库记录表成功!");
                }

                //if (err != "") {
                //    return BuildErpResult(2, err + "其他信息正常已写入");
                //}
                //return BuildErpResult(0, $"更改物料信息成功");

                // NOTE：暂时不检查，万一ERP发错了，可以选择重发

                //if (errList.Count > 0) {
                //    info = "更改物料信息部分成功，部分失败，原因：当前货位已经给过物料信息";
                //}
                //else {
                //    info = "更改物料信息成功!";
                //}
            }
            catch (Exception ex) {
                return BuildErpResult(1, $"发生了异常：{ex.Message}");
@@ -1017,23 +919,22 @@
                    return BuildErpResult(400, "不能传入空的数据列表");
                }

                //var err = "";
                //var cgDetailList = new List<TN_CG_Detail>();
                //var recordList = new List<TN_Outbound_DataRecord>();
                var insetRecordList = new List<TN_Outbound_DataRecord>();
                var deleteRecordOldList = new List<TN_Outbound_DataRecord>();
                var insertRecordList = new List<TN_Outbound_DataRecord>();
                //var deleteRecordOldList = new List<TN_Outbound_DataRecord>();
                foreach (var issue in model.materialIssues) {
                    var recordOld = db.Queryable<TN_Outbound_DataRecord>()
                        .Where(r => r.S_LOCATION_CODE == "HJQ-" + issue.locationCode.Trim()).First();
                    if (recordOld != null) {
                        deleteRecordOldList.Add(recordOld);
                        //errList.Add(recordOld);
                        //continue;
                    //var recordOld = db.Queryable<TN_Outbound_DataRecord>()
                    //    .Where(r => r.S_LOCATION_CODE == issue.locationCode.Trim()).First();
                    //if (recordOld != null) {
                    //    deleteRecordOldList.Add(recordOld);
                    //}

                    if (!float.TryParse(issue.actualIssuedQty, out var _)) {
                        return BuildErpResult(400, $"实发数量不合法! 请确保字符串的值可以解析为数值! 领用单号='{issue.withdrawalOrderNo}', 实发数量='{issue.actualIssuedQty}'");
                    }

                    // 写入记录表
                    var record = new TN_Outbound_DataRecord {
                        S_LOCATION_CODE = "HJQ-" + issue.locationCode.Trim(),
                        S_LOCATION_CODE = issue.locationCode.Trim(),
                        S_ORDER_NO = issue.withdrawalOrderNo,
                        S_ITEM_CODE = issue.itemCode,
                        S_ITEM_NAME = issue.itemName,
@@ -1047,55 +948,323 @@
                        S_LINE_CODE = issue.lineCode,
                        S_BATCH_NO = issue.batchNo
                    };
                    insetRecordList.Add(record);

                    //// 查询对应物料
                    //var cgDetail = db.Queryable<TN_Location, TN_Loc_Container, TN_CG_Detail>
                    //    ((l, c, d) => l.S_CODE == c.S_LOC_CODE && c.S_CNTR_CODE == d.S_CNTR_CODE)
                    //    .Where(l => l.S_CODE == issue.locationCode)
                    //    .Select((l, c, d) => d)
                    //    .First();

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

                    //cgDetail.S_ITEM_CODE = issue.itemCode;
                    //cgDetail.S_ITEM_NAME = issue.itemName;

                    //cgDetailList.Add(cgDetail);
                    insertRecordList.Add(record);
                }

                using (var tran = db.Ado.UseTran()) {
                    if (deleteRecordOldList.Count != 0 && db.Deleteable<TN_Outbound_DataRecord>(deleteRecordOldList).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildErpResult(500, $"删除旧出库记录数据失败：{JsonConvert.SerializeObject(deleteRecordOldList)}");
                    }
                    //if (deleteRecordOldList.Count != 0 && db.Deleteable<TN_Outbound_DataRecord>(deleteRecordOldList).ExecuteCommand() <= 0) {
                    //    tran.RollbackTran();
                    //    return BuildErpResult(500, $"删除旧出库记录数据失败：{JsonConvert.SerializeObject(deleteRecordOldList)}");
                    //}

                    if (db.Insertable<TN_Outbound_DataRecord>(insetRecordList).ExecuteCommand() <= 0) {
                    if (db.Insertable<TN_Outbound_DataRecord>(insertRecordList).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildErpResult(500, $"写入出库记录表失败");
                    }

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

                    tran.CommitTran();
                    return BuildErpResult(0, $"写入出库记录表成功!");
                }

                //if (err != "") {
                //    return BuildErpResult(2, err + "其他信息正常已写入");
                //}
                //return BuildErpResult(0, $"更改物料信息成功");

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

        // 盘点功能（新）------------------------------------

        internal static SimpleResult CheckOutboundOnce(CheckOutboundOnceInfo model) {
            var taskName = TaskName.盘点理货出库;
            var db = new SqlHelper<object>().GetInstance();

            try {
                var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_CNTR_CODE == model.cntrCode);
                if (locCntrRel == null) {
                    return BuildSimpleResult(3, $"容器 {model.cntrCode} 没有找到对应的货位");
                }

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

                // 终点位置：货架（没有货物，没有锁）
                var endLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.endLoc && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y");
                if (endLoc == null) {
                    return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                }

                var countOrder = db.Queryable<TN_AG_Count_Order>().Where(o => o.S_CNTR_CODE == locCntrRel.S_CNTR_CODE).First();
                if (countOrder == null) {
                    return BuildSimpleResult(6, $"没有找到对应容器{model.cntrCode}的盘点单号!");
                }
                countOrder.N_B_STATE = 1;

                var unFinishedCount = db.Queryable<TN_AG_Count_Order>().Where(a => a.S_CP_NO == countOrder.S_CP_NO && a.S_COUNT_NO != countOrder.S_COUNT_NO && a.N_B_STATE == 0).Count();

                var cntID = locCntrRel.S_CNTR_CODE;
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntID, taskName);
                LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
                LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁

                using (var tran = db.Ado.UseTran()) {
                    if (unFinishedCount == 0 && db.Updateable<TN_AG_Count_Plan>().SetColumns(a =>a.N_B_STATE == 1).Where(a => a.S_CP_NO == countOrder.S_CP_NO).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"更新盘点计划单状态为1失败！单号：{countOrder.S_CP_NO}");
                    }

                    if (db.Updateable<TN_AG_Count_Order>(countOrder).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(500,
                            $"更新盘点单状态为1失败："+ JsonConvert.SerializeObject(countOrder));
                    }

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

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

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

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

        /// <summary>
        /// 盘点理货出库(WMS)
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResult CheckOutbound(CheckOutboundInfo model) {
            var taskName = TaskName.盘点理货出库;
            var db = new SqlHelper<object>().GetInstance();

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

                var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
                if (locCntrRel == null) {
                    return BuildSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
                }

                // 终点位置：货架（没有货物，没有锁）
                var endLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.endLoc && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y");
                if (endLoc == null) {
                    return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                }

                var cntID = locCntrRel.S_CNTR_CODE;
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntID, taskName);
                LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
                LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁

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

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

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

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

        /// <summary>
        /// 盘点理货回库(WMS)
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        internal static SimpleResult CheckInbound(CheckInboundInfo model) {
            var taskName = TaskName.盘点理货回库;
            var db = new SqlHelper<object>().GetInstance();

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

                var locCntrRel = db.Queryable<TN_Loc_Container>().First(a => a.S_LOC_CODE == model.startLoc);
                if (locCntrRel == null) {
                    return BuildSimpleResult(3, $"起点位置 {model.startLoc} 没有绑定容器，无可回库的物料");
                }

                // 终点位置：货架（没有货物，没有锁）
                var endLoc = db.Queryable<TN_Location>().First(a => a.S_CODE == model.endLoc && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y" && Settings.Areas[AreaIndex.H货架区].Contains(a.S_AREA_CODE));
                if (endLoc == null) {
                    return BuildSimpleResult(4, $"终点位置 {model.endLoc} 不具备放货条件");
                }

                var cntID = locCntrRel.S_CNTR_CODE;
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntID, taskName);
                LocationHelper.LockLoc(ref startLoc, 2); // 起点出库锁
                LocationHelper.LockLoc(ref endLoc, 1); // 终点入库锁

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

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

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

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

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

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

                var locCntrRel = db.Queryable<TN_Loc_Container>()
                    //.LeftJoin<TN_CG_Detail>((c, d) => c.S_CNTR_CODE == d.S_CNTR_CODE)
                    .Where(c => c.S_LOC_CODE == model.locCode).First();
                if (locCntrRel == null) {
                    return BuildSimpleResult(2, $"当前货位{model.locCode}没有容器！");
                }

                var cgDetail = db.Queryable<TN_CG_Detail>()
                    .Where(d => d.S_CNTR_CODE == locCntrRel.S_CNTR_CODE && d.S_ITEM_CODE == model.itemCode).First();
                if (cgDetail == null) {
                    return BuildSimpleResult(3, $"当前货位{model.locCode}上的容器{locCntrRel.S_CNTR_CODE}没有物品{model.itemCode}！");
                }

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

                var countDiff = db.Queryable<TN_AG_Count_Diff>().Where(d => d.S_CNTR_CODE == locCntrRel.S_CNTR_CODE && d.S_ITEM_CODE == model.itemCode).First();
                if (countDiff == null) {
                    return BuildSimpleResult(4, $"当前物料所在容器{locCntrRel.S_CNTR_CODE}物料信息{model.itemCode}没有生成对应的盘点差异表！");
                }

                countDiff.F_QTY = cgDetail.F_QTY;
                countDiff.F_ACTUAL_QTY = model.qty;
                //countDiff.S_ITEM_CODE = cgDetail.S_ITEM_CODE;
                cgDetail.F_QTY = model.qty;
                //if (db.Insertable<TN_Count_Diff>(countDiff).ExecuteCommand() <= 0) {
                //    return BuildSimpleResult(3, $"插入盘点差异表失败");
                //}
                using (var tran = db.Ado.UseTran()) {
                    if (db.Updateable<TN_AG_Count_Diff>(countDiff).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(5, $"更新盘点差异表失败");
                    }

                    if (db.Updateable<TN_CG_Detail>(cgDetail).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        return BuildSimpleResult(5, $"更新物料信息失败");
                    }

                    tran.CommitTran();
                }

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

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


    }
}