重构盘点单表结构，修复部分盘点逻辑

kazelee

9 天以前 b183905d45e279eca8a845f532fc2d2edd540edb

 api/ApiHelper.cs

@@ -358,7 +358,7 @@
                                $"插入容器货品明细表失败：容器{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,
@@ -1097,5 +1097,330 @@
                return BuildErpResult(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 CreateCountPlan(CreateCountPlanInfo model) {
        //    var db = new SqlHelper<object>().GetInstance();
        //    try {

        //        var countPlan = new TN_Count_Plan() {
        //            S_CP_NO = GenerateNo("盘点计划", "PDJH"), // CP =》PDJH
        //            S_TYPE = model.countType,
        //        };

        //        if (model.countType == "货位") {
        //            countPlan.S_LOC_CODE = model.targetId;
        //        }
        //        else if (model.countType == "物料") {
        //            countPlan.S_ITEM_CODE = model.targetId;
        //        }
        //        else {
        //            return BuildSimpleResult(2, $"创建盘点计划失败：不合法的盘点类型 '{model.countType}'");
        //        }

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

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

        //    }
        //    catch (Exception ex) {

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

        //public static SimpleResult CreateCountOrder(CreateCountOrderInfo model) {
        //    var db = new SqlHelper<object>().GetInstance();
        //    var info = "";
        //    try {
        //        var countPlan = db.Queryable<TN_Count_Plan>()
        //            .Where(a => a.S_CP_NO == model.planId).First();

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

        //        var countOrder = new TN_Count_Order() {
        //            S_CP_NO = model.planId,
        //            S_COUNT_NO = GenerateNo("盘点单", "PDD"), // CN =》PDD
        //        };

        //        var countDetailList = new List<TN_Count_CG_Detail>();
        //        if (countPlan.S_TYPE == "货位") {
        //            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 == countPlan.S_LOC_CODE)
        //                .Select((l, c, d) => d).First();

        //            if (cgDetail == null) {
        //                return BuildSimpleResult(3, $"未找到指定货位{countPlan.S_LOC_CODE}上的物料");
        //            }

        //            var countDetail = new TN_Count_CG_Detail {
        //                S_COUNT_NO = countOrder.S_COUNT_NO,
        //                S_CNTR_CODE = cgDetail.S_CNTR_CODE,
        //                S_ITEM_CODE = cgDetail.S_ITEM_CODE,
        //            };

        //            countDetailList.Add(countDetail);
        //        }
        //        else if (countPlan.S_TYPE == "物料") {
        //            var cgDetail = db.Queryable<TN_CG_Detail>()
        //                .Where(d => d.S_ITEM_CODE == countPlan.S_ITEM_CODE).First(); // ToList -> First

        //            if (cgDetail == null) {
        //                return BuildSimpleResult(3, $"未找到指定的物料{countPlan.S_ITEM_CODE}");
        //            }

        //            //foreach (var cgDetail in cgDetailList) {
        //            //    var countDetail = new TN_Count_CG_Detail {
        //            //        S_COUNT_NO = countOrder.S_COUNT_NO,
        //            //        S_CNTR_CODE = cgDetail.S_CNTR_CODE,
        //            //        S_ITEM_CODE = cgDetail.S_ITEM_CODE,
        //            //    };

        //            //    countDetailList.Add(countDetail);
        //            //}

        //            var countDetail = new TN_Count_CG_Detail {
        //                S_COUNT_NO = countOrder.S_COUNT_NO,
        //                S_CNTR_CODE = cgDetail.S_CNTR_CODE,
        //                S_ITEM_CODE = cgDetail.S_ITEM_CODE,
        //            };

        //            countDetailList.Add(countDetail);
        //        }
        //        else {
        //            return BuildSimpleResult(3, $"计划单'{model.planId}'的类型{countPlan.S_TYPE}不合法");
        //        }

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

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

        //            tran.CommitTran();
        //        }

        //        return BuildSimpleResult(0, "创建盘点单成功");
        //    }
        //    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).First();
                if (cgDetail == null) {
                    return BuildSimpleResult(3, $"当前货位{model.locCode}上的容器{locCntrRel.S_CNTR_CODE}没有物品！");
                }

                //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).First();
                if (countDiff == null) {
                    return BuildSimpleResult(4, $"当前物料所在容器{locCntrRel.S_CNTR_CODE}物料信息没有生成对应的盘点差异表！");
                }

                countDiff.F_QTY = cgDetail.F_QTY;
                countDiff.F_ACTUAL_QTY = model.qty;
                //countDiff.S_ITEM_CODE = cgDetail.S_ITEM_CODE;

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

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

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

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


    }
}