Example #1
0
        public bool AuditStkOutBill(STK_OutParam param)
        {
            bool auditFlag = true;

            try
            {
                STK_OutResult outResult = this.GetInfo(param);
                if (outResult != null)
                {
                    bool isAllowAudit = true;
                    if (outResult.ApproveStatus == "待提交")
                    {
                        isAllowAudit = false;
                        throw new WarnException("出库单当前状态为:【待提交】,请先提交!");
                    }
                    else if (outResult.ApproveStatus == "审核完成")
                    {
                        isAllowAudit = false;
                        throw new WarnException("出库单当前状态为:【审核完成】,禁止重复审核!");
                    }
                    if (isAllowAudit)
                    {
                        outResult.Status        = "Complete";
                        outResult.ApproveStatus = "审核完成";
                        WCFAddUpdateResult ret = this.AddOrUpdate(outResult);

                        if (ret.KeyGuid.ToGuid() == Guid.Empty)
                        {
                            auditFlag = false;
                        }
                        else
                        {
                            #region 定义相关变量(可重复使用)
                            STK_OutLineBLL outLineBLL = new STK_OutLineBLL();
                            outLineBLL.SessionInfo = this.SessionInfo;
                            STK_InBLL inBLL = new STK_InBLL();
                            inBLL.SessionInfo = this.SessionInfo;
                            STK_InLineBLL inLineBLL = new STK_InLineBLL();
                            inLineBLL.SessionInfo = this.SessionInfo;

                            ORD_PurchaseOrderLineBLL purOrderLineBLL = new ORD_PurchaseOrderLineBLL();
                            purOrderLineBLL.SessionInfo = this.SessionInfo;
                            ORD_PurchaseOrderBLL purOrderBLL = new ORD_PurchaseOrderBLL();
                            purOrderBLL.SessionInfo = this.SessionInfo;
                            ORD_SalesOrderBLL saleOrderBLL = new ORD_SalesOrderBLL();
                            saleOrderBLL.SessionInfo = this.SessionInfo;
                            ORD_SalesOrderLineBLL saleOrderLineBLL = new ORD_SalesOrderLineBLL();
                            saleOrderLineBLL.SessionInfo = this.SessionInfo;
                            ORD_PurchaseReturnBLL purReturnBLL = new ORD_PurchaseReturnBLL();
                            purReturnBLL.SessionInfo = this.SessionInfo;
                            ORD_PurchaseReturnLineBLL purReturnLineBLL = new ORD_PurchaseReturnLineBLL();
                            purReturnLineBLL.SessionInfo = this.SessionInfo;
                            STK_StockSheetBLL stockSheetBLL = new STK_StockSheetBLL();
                            stockSheetBLL.SessionInfo = this.SessionInfo;
                            STK_StockBLL stockBLL = new STK_StockBLL();
                            stockBLL.SessionInfo = this.SessionInfo;
                            STK_InOutLinkBLL inOutLinkBLL = new STK_InOutLinkBLL();
                            inOutLinkBLL.SessionInfo = this.SessionInfo;
                            List <ORD_SalesOrderResult>         saleList          = null;
                            List <ORD_SalesOrderLineResult>     saleLineList      = null;
                            List <ORD_PurchaseOrderLineResult>  purLineList       = null;
                            List <ORD_PurchaseReturnResult>     purReturnList     = null;
                            List <ORD_PurchaseReturnLineResult> purReturnLineList = null;
                            List <STK_InResult>         stkInList         = null;
                            List <STK_InLineResult>     stkInLineList     = null;
                            List <STK_InLineResult>     effStkInLineList  = null;
                            List <STK_OutResult>        stkOutList        = null;
                            List <STK_OutLineResult>    stkOutLineList    = null;
                            List <STK_OutLineResult>    effStkOutLineList = null;
                            List <STK_StockResult>      stockList         = null;
                            List <STK_StockSheetResult> stkStockSheetList = null;

                            Guid?[] ItemCodes        = null;
                            Guid?[] StkInGuids       = null;
                            Guid?[] StkInLineGuids   = null;
                            Guid?[] EffStkInGuids    = null;
                            Guid?[] StkOutGuids      = null;
                            Guid?[] _stkOutLineGuids = null;
                            Guid?[] EffStkOutGuids   = null;
                            Guid?[] POGuids          = null;
                            Guid?[] POLineGuids      = null;
                            Guid?[] SOGuids          = null;
                            Guid?[] SOLineGuids      = null;
                            Guid?[] PRGuids          = null;
                            Guid?[] PRLineGuids      = null;
                            #endregion
                            //获取出库单下的出库明细集合
                            List <STK_OutLineResult> outLineList = outLineBLL.GetList(new STK_OutLineParam()
                            {
                                StkOutGuid = ret.KeyGuid
                            });
                            //获取出库单下的关联明细集合
                            List <STK_InOutLinkResult> inOutLinkList = inOutLinkBLL.GetList(new STK_InOutLinkParam()
                            {
                                StkOutGuid = ret.KeyGuid
                            });
                            if (outLineList != null && outLineList.Count > 0)
                            {
                                #region 减少库存,形成出库流水
                                ItemCodes = outLineList.Select(a => a.ItemCode).Distinct().ToArray();
                                stockList = stockBLL.GetList(new STK_StockParam()
                                {
                                    ItemCodes = ItemCodes
                                });

                                stkStockSheetList = new List <STK_StockSheetResult>();
                                STK_StockSheetResult stkStockSheetResult = null;
                                foreach (STK_OutLineResult outLineResult in outLineList)
                                {
                                    STK_StockResult stockResult = stockList.FirstOrDefault(a => a.ItemCode == outLineResult.ItemCode.ToGuid());
                                    if (stockResult != null)
                                    {
                                        stockResult.InvQty                    -= outLineResult.Qty;
                                        stockResult.BookedQty                 -= outLineResult.Qty;
                                        stkStockSheetResult                    = new STK_StockSheetResult();
                                        stkStockSheetResult.SSType             = 2;
                                        stkStockSheetResult.SourceBillGuid     = outResult.StkOutGuid;
                                        stkStockSheetResult.SourceBillNo       = outResult.BillNo;
                                        stkStockSheetResult.SourceBillLineGuid = outLineResult.StkOutLineGuid;
                                        stkStockSheetResult.ItemCode           = outLineResult.ItemCode;
                                        stkStockSheetResult.Model              = outLineResult.Model;
                                        stkStockSheetResult.Brand              = outLineResult.Brand;
                                        stkStockSheetResult.Batch              = outLineResult.Batch;
                                        stkStockSheetResult.Package            = outLineResult.Package;
                                        stkStockSheetResult.Quality            = outLineResult.Quality;
                                        stkStockSheetResult.MPQ                = outLineResult.MPQ;
                                        stkStockSheetResult.MarkCode           = outLineResult.MarkCode;
                                        stkStockSheetResult.Currency           = outLineResult.Currency;
                                        stkStockSheetResult.FlowQty            = outLineResult.Qty;
                                        stkStockSheetResult.FlowPrice          = outLineResult.UnitPrice;
                                        stkStockSheetResult.FlowAmount         = outLineResult.Amount;
                                        stkStockSheetList.Add(stkStockSheetResult);
                                    }
                                }
                                stockBLL.UpdateOrInsertList(stockList);
                                stockSheetBLL.UpdateOrInsertList(stkStockSheetList);


                                #endregion

                                #region 回写关联的入库单的出库数量和出库状态,入库单关联单据的出库数量和出库状态,出库单关联单据的出库数量和出库状态

                                #region 回写关联入库单的出库数量出库状态

                                //获取出库明细的guid
                                StkInLineGuids = inOutLinkList.Select(a => a.StkInLineGuid).Distinct().ToArray();

                                if (StkInLineGuids != null && StkInLineGuids.Length > 0)
                                {
                                    //获取出库明细所关联的入库明细
                                    stkInLineList = inLineBLL.GetList(new STK_InLineParam()
                                    {
                                        StkInLineGuids = StkInLineGuids
                                    });
                                    if (stkInLineList != null && stkInLineList.Count > 0)
                                    {
                                        //获取出库明细所关联的入库明细对应的出库明细
                                        List <STK_InOutLinkResult> linkList = inOutLinkBLL.GetList(new STK_InOutLinkParam()
                                        {
                                            StkInLineGuids = StkInLineGuids
                                        });
                                        if (linkList != null && linkList.Count > 0)
                                        {
                                            _stkOutLineGuids = linkList.Select(a => a.StkOutLineGuid).Distinct().ToArray();
                                            stkOutLineList   = outLineBLL.GetList(new STK_OutLineParam()
                                            {
                                                StkOutLineGuids = _stkOutLineGuids
                                            });
                                            if (stkOutLineList != null && stkOutLineList.Count > 0)
                                            {
                                                //获取出库明细对应的出库主单guid
                                                StkOutGuids = stkOutLineList.Select(a => a.StkOutGuid).Distinct().ToArray();
                                                if (StkOutGuids != null && StkOutGuids.Length > 0)
                                                {
                                                    //获取出库明细对应的出库主单
                                                    stkOutList = this.GetList(new STK_OutParam()
                                                    {
                                                        StkOutGuids = StkOutGuids, Status = "Complete"
                                                    });
                                                    if (stkOutList != null && stkOutList.Count > 0)
                                                    {
                                                        //获取有效的出库主单guid
                                                        EffStkOutGuids = stkOutList.Select(a => a.StkOutGuid).Distinct().ToArray();
                                                        //获取有效的出库明细集合
                                                        effStkOutLineList = stkOutLineList.Where(a => EffStkOutGuids.Contains(a.StkOutGuid)).ToList();
                                                        foreach (STK_InLineResult stkInLineResult in stkInLineList)
                                                        {
                                                            //汇总出库明细的出库数量
                                                            int?qty = effStkOutLineList.Where(a => a.StkInLineGuid == stkInLineResult.StkInLineGuid).Sum(a => a.Qty.ToInt32());
                                                            //回写入库明细的出库数量
                                                            stkInLineResult.StkOutQty = qty;
                                                        }
                                                    }
                                                }
                                                //更新入库明细的集合
                                                inLineBLL.UpdateOrInsertList(stkInLineList);
                                                //获取入库主单guid
                                                StkInGuids = stkInLineList.Select(a => a.StkInGuid).Distinct().ToArray();
                                                foreach (Guid stkinguid in StkInGuids)
                                                {
                                                    //更新入库单的状态
                                                    inBLL.UpdateStatus(new STK_InParam()
                                                    {
                                                        StkInGuid = stkinguid
                                                    });
                                                    //获取入库单
                                                    STK_InResult stkInResult = inBLL.GetInfo(new STK_InParam()
                                                    {
                                                        StkInGuid = stkinguid
                                                    });
                                                    if (stkInResult.BillType == "PO_IN")
                                                    {
                                                        #region 回写采购单的出库的数量出库状态
                                                        //找到入库明细所关联的采购明细guid和采购明细集合
                                                        POLineGuids = stkInLineList.Where(a => a.StkInGuid == stkinguid).Select(a => a.SourceBillLineGuid).Distinct().ToArray();
                                                        if (POLineGuids != null && POLineGuids.Length > 0)
                                                        {
                                                            purLineList = purOrderLineBLL.GetList(new ORD_PurchaseOrderLineParam()
                                                            {
                                                                POLineGuids = POLineGuids
                                                            });
                                                            if (purLineList != null && purLineList.Count > 0)
                                                            {
                                                                //找到采购单明细关联的入库明细
                                                                List <STK_InLineResult> linkInLineList = inLineBLL.GetList(new STK_InLineParam()
                                                                {
                                                                    SourceBillLineGuids = POLineGuids
                                                                });
                                                                if (linkInLineList != null && linkInLineList.Count > 0)
                                                                {
                                                                    //找到采购明细关联的入库明细的入库主单guid
                                                                    Guid?[] LinkInGuids = linkInLineList.Select(a => a.StkInGuid).Distinct().ToArray();
                                                                    if (LinkInGuids != null && LinkInGuids.Length > 0)
                                                                    {
                                                                        //找到采购单明细关联的入库明细所在的入库主单
                                                                        stkInList = inBLL.GetList(new STK_InParam()
                                                                        {
                                                                            StkInGuids = LinkInGuids, Status = "Complete"
                                                                        });
                                                                        if (stkInList != null && stkInList.Count > 0)
                                                                        {
                                                                            //有效的入库主单guid
                                                                            EffStkInGuids = stkInList.Select(a => a.StkInGuid).Distinct().ToArray();
                                                                            //有效的入库明细集合
                                                                            effStkInLineList = linkInLineList.Where(a => EffStkInGuids.Contains(a.StkInGuid)).ToList();
                                                                            foreach (ORD_PurchaseOrderLineResult purLineResult in purLineList)
                                                                            {
                                                                                //汇总有效的入库明细的出库数量
                                                                                int?qty = effStkInLineList.Where(a => a.SourceBillLineGuid == purLineResult.POLineGuid).Sum(a => a.StkOutQty).ToInt32();
                                                                                //更新采购明细的出库数量
                                                                                purLineResult.StkOutQty = qty;
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                                //更新采购明细集合
                                                                purOrderLineBLL.UpdateOrInsertList(purLineList);
                                                                POGuids = purLineList.Select(a => a.POGuid).Distinct().ToArray();
                                                                foreach (Guid poguid in POGuids)
                                                                {
                                                                    purOrderBLL.UpdateStatus(new ORD_PurchaseOrderParam()
                                                                    {
                                                                        POGuid = poguid
                                                                    });
                                                                }
                                                            }
                                                        }

                                                        #endregion
                                                    }
                                                    else if (stkInResult.BillType == "SOR_IN")
                                                    {
                                                    }
                                                    else if (stkInResult.BillType == "ZX_IN")
                                                    {
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                #endregion


                                #region 回写出库单关联的业务单据的出库数量和出库状态
                                if (outResult.BillType == "SO_OUT")
                                {
                                    #region 回写销售单的出库数量和出库状态
                                    //获取出库明细对应的销售明细guid
                                    SOLineGuids = outLineList.Select(a => a.SourceBillLineGuid).Distinct().ToArray();
                                    if (SOLineGuids != null && SOLineGuids.Length > 0)
                                    {
                                        //获取出库明细对应的销售明细
                                        saleLineList = saleOrderLineBLL.GetList(new ORD_SalesOrderLineParam()
                                        {
                                            SOLineGuids = SOLineGuids
                                        });
                                        if (saleLineList != null && saleLineList.Count > 0)
                                        {
                                            //获取出库明细对应的销售明细关联关联的出库明细
                                            stkOutLineList = outLineBLL.GetList(new STK_OutLineParam()
                                            {
                                                SourceBillLineGuids = SOLineGuids
                                            });
                                            if (stkOutLineList != null && stkOutLineList.Count > 0)
                                            {
                                                //获取出库明细对应的出库主单guid
                                                StkOutGuids = stkOutLineList.Select(a => a.StkOutGuid).Distinct().ToArray();
                                                if (StkOutGuids != null && StkOutGuids.Length > 0)
                                                {
                                                    //获取出库明细对应的出库主单
                                                    stkOutList = this.GetList(new STK_OutParam()
                                                    {
                                                        StkOutGuids = StkOutGuids, Status = "Complete"
                                                    });
                                                    if (stkOutList != null && stkOutList.Count > 0)
                                                    {
                                                        //获取有效的出库主单guid
                                                        EffStkOutGuids = stkOutList.Select(a => a.StkOutGuid).Distinct().ToArray();
                                                        //获取有效的出库明细集合
                                                        effStkOutLineList = stkOutLineList.Where(a => EffStkOutGuids.Contains(a.StkOutGuid)).ToList();
                                                        foreach (ORD_SalesOrderLineResult orderLineResult in saleLineList)
                                                        {
                                                            //汇总有效的出库明细的出库数量
                                                            int?qty = effStkOutLineList.Where(a => a.SourceBillLineGuid == orderLineResult.SOLineGuid).Sum(a => a.Qty).ToInt32();
                                                            orderLineResult.StkOutQty = qty;
                                                        }
                                                    }
                                                }
                                            }
                                            saleOrderLineBLL.UpdateOrInsertList(saleLineList);
                                            SOGuids = saleLineList.Select(a => a.SOGuid).Distinct().ToArray();
                                            foreach (Guid soguid in SOGuids)
                                            {
                                                saleOrderBLL.UpdateStatus(new ORD_SalesOrderParam()
                                                {
                                                    SOGuid = soguid
                                                });
                                            }
                                        }
                                    }
                                    #endregion
                                }
                                else if (outResult.BillType == "POR_OUT")
                                {
                                    #region 回写采购退货单的出库数量和出库状态
                                    //获取出库明细对应的退货明细guid
                                    PRLineGuids = outLineList.Select(a => a.SourceBillLineGuid).Distinct().ToArray();
                                    if (PRLineGuids != null && PRLineGuids.Length > 0)
                                    {
                                        //获取出库明细对应的退货明细
                                        purReturnLineList = purReturnLineBLL.GetList(new ORD_PurchaseReturnLineParam()
                                        {
                                            PRLineGuids = PRLineGuids
                                        });
                                        if (purReturnLineList != null && purReturnLineList.Count > 0)
                                        {
                                            //获取出库明细对应的退货明细关联关联的出库明细
                                            stkOutLineList = outLineBLL.GetList(new STK_OutLineParam()
                                            {
                                                SourceBillLineGuids = PRLineGuids
                                            });
                                            if (stkOutLineList != null && stkOutLineList.Count > 0)
                                            {
                                                //获取出库明细对应的出库主单guid
                                                StkOutGuids = stkOutLineList.Select(a => a.StkOutGuid).Distinct().ToArray();
                                                if (StkOutGuids != null && StkOutGuids.Length > 0)
                                                {
                                                    //获取出库明细对应的出库主单
                                                    stkOutList = this.GetList(new STK_OutParam()
                                                    {
                                                        StkOutGuids = StkOutGuids, Status = "Complete"
                                                    });
                                                    if (stkOutList != null && stkOutList.Count > 0)
                                                    {
                                                        //获取有效的出库主单guid
                                                        EffStkOutGuids = stkOutList.Select(a => a.StkOutGuid).Distinct().ToArray();
                                                        //获取有效的出库明细集合
                                                        effStkOutLineList = stkOutLineList.Where(a => EffStkOutGuids.Contains(a.StkOutGuid)).ToList();
                                                        foreach (ORD_PurchaseReturnLineResult purReturnLineResult in purReturnLineList)
                                                        {
                                                            //汇总有效的出库明细的出库数量
                                                            int?qty = effStkOutLineList.Where(a => a.SourceBillLineGuid == purReturnLineResult.PRLineGuid).Sum(a => a.Qty).ToInt32();
                                                            purReturnLineResult.StkOutQty = qty;
                                                        }
                                                    }
                                                }
                                            }
                                            purReturnLineBLL.UpdateOrInsertList(purReturnLineList);
                                            PRGuids = purReturnLineList.Select(a => a.PRGuid).Distinct().ToArray();
                                            foreach (Guid prguid in PRGuids)
                                            {
                                                purReturnBLL.UpdateStatus(new ORD_PurchaseReturnParam()
                                                {
                                                    PRGuid = prguid
                                                });
                                            }
                                        }
                                    }
                                    #endregion
                                }
                                else if (outResult.BillType == "ZX_OUT")
                                {
                                }
                                #endregion
                                #endregion
                            }
                        }
                    }
                }
                else
                {
                    throw new WarnException("要审核的出库单在系统中不存在!");
                }
            }
            catch (WarnException exp)
            {
                throw exp;
            }
            catch (Exception exp)
            {
                LogInfoBLL.WriteLog(this.SessionInfo, exp);
                throw exp;
            }
            return(auditFlag);
        }
Example #2
0
        /// <summary>
        /// 操作预留
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>
        public bool OperateReserve(STK_StockReserveResult result)
        {
            this.CheckSession();
            try
            {
                //预留调整量
                int?tempReserveQty = 0;
                ORD_SalesOrderLineResult orderLineResult = new ORD_SalesOrderLineResult();
                ORD_SalesOrderLineBLL    orderLineBLL    = new ORD_SalesOrderLineBLL();
                orderLineBLL.SessionInfo = this.SessionInfo;
                ORD_PurchaseReturnLineResult returnLineResult = new ORD_PurchaseReturnLineResult();
                ORD_PurchaseReturnLineBLL    returnLineBLL    = new ORD_PurchaseReturnLineBLL();
                returnLineBLL.SessionInfo = this.SessionInfo;

                //空值转换为零
                if (result.ReserveQty == null)
                {
                    result.ReserveQty = 0;
                }
                // 预留明细的业务类型
                switch (result.SourceBillType)
                {
                case "销售出库":
                    orderLineResult = orderLineBLL.GetInfo(new ORD_SalesOrderLineParam()
                    {
                        SOLineGuid = result.SourceBillLineGuid
                    });
                    if (orderLineResult != null)
                    {
                        if (orderLineResult.Qty == null)
                        {
                            orderLineResult.Qty = 0;
                        }
                        if (orderLineResult.ReserveQty == null)
                        {
                            orderLineResult.ReserveQty = 0;
                        }
                        tempReserveQty = orderLineResult.Qty - orderLineResult.ReserveQty;
                    }
                    break;

                case "采购退货出库":
                    returnLineResult = returnLineBLL.GetInfo(new ORD_PurchaseReturnLineParam()
                    {
                        PRLineGuid = result.SourceBillLineGuid
                    });
                    if (returnLineResult != null)
                    {
                        if (returnLineResult.Qty == null)
                        {
                            returnLineResult.Qty = 0;
                        }
                        if (returnLineResult.ReserveQty == null)
                        {
                            returnLineResult.ReserveQty = 0;
                        }
                        tempReserveQty = returnLineResult.Qty - returnLineResult.ReserveQty;
                    }
                    break;
                }

                //获取已存在的预留信息
                STK_StockReserveResult oldReserveResult = null;
                if (result.SRGuid != null)
                {
                    STK_StockReserveParam reserveParam = new STK_StockReserveParam();
                    reserveParam.SRGuid = result.SRGuid;
                    oldReserveResult    = this.GetInfo(reserveParam);
                }
                if (oldReserveResult != null)
                {
                    if (oldReserveResult.ReserveQty == null)
                    {
                        orderLineResult.ReserveQty = 0;
                    }
                    //修改预留数量,预留量增加
                    if (result.ReserveQty >= oldReserveResult.ReserveQty)
                    {
                        tempReserveQty  = result.ReserveQty - oldReserveResult.ReserveQty;
                        result.OperFlag = true;
                    }
                    //修改预留数量,预留量减少
                    else if (result.ReserveQty < oldReserveResult.ReserveQty)
                    {
                        tempReserveQty  = oldReserveResult.ReserveQty - result.ReserveQty;
                        result.OperFlag = false;
                    }
                }
                //获取库存信息
                STK_StockBLL stockBLL = new STK_StockBLL();
                stockBLL.SessionInfo = this.SessionInfo;
                STK_StockResult stockResult = stockBLL.GetInfo(new STK_StockParam()
                {
                    ItemCode = result.ItemCode
                });
                if (stockResult != null)
                {
                    //空值转换为零
                    if (stockResult.UsableQty == null)
                    {
                        stockResult.UsableQty = 0;
                    }
                    if (stockResult.BookedQty == null)
                    {
                        stockResult.BookedQty = 0;
                    }
                }

                int?UsableQty = stockResult.UsableQty;
                //删除预留信息
                if (result.IsDeleted.ToBooleanHasNull())
                {
                    result = oldReserveResult;
                    stockResult.UsableQty += result.ReserveQty;
                    stockResult.BookedQty -= result.ReserveQty;
                    switch (result.SourceBillType)
                    {
                    case "销售出库":
                        orderLineResult.ReserveQty -= result.ReserveQty;
                        break;

                    case "采购退货出库":
                        returnLineResult.ReserveQty -= result.ReserveQty;
                        break;
                    }
                }
                //新增或者修改预留信息
                else
                {
                    switch (result.OperFlag)
                    {
                    case true:      //增加
                        //预留信息已经存在
                        if (oldReserveResult != null)
                        {
                            result = oldReserveResult;
                            if (UsableQty >= tempReserveQty)      //大于需要预留数量
                            {
                                result.ReserveQty += tempReserveQty;
                            }
                            else      //小于需要预留数量
                            {
                                result.ReserveQty += UsableQty;
                            }
                        }
                        //新的预留
                        else
                        {
                            if (UsableQty >= tempReserveQty)      //大于需要预留数量
                            {
                                result.ReserveQty = tempReserveQty;
                            }
                            else      //小于需要预留数量
                            {
                                result.ReserveQty = UsableQty;
                            }
                        }
                        if (UsableQty >= tempReserveQty)      //大于需要预留数量
                        {
                            stockResult.UsableQty -= tempReserveQty;
                            stockResult.BookedQty += tempReserveQty;
                            switch (result.SourceBillType)
                            {
                            case "销售出库":
                                orderLineResult.ReserveQty += tempReserveQty;
                                break;

                            case "采购退货出库":
                                returnLineResult.ReserveQty += tempReserveQty;
                                break;
                            }
                        }
                        else
                        {
                            stockResult.UsableQty -= UsableQty;
                            stockResult.BookedQty += UsableQty;
                            switch (result.SourceBillType)
                            {
                            case "销售出库":
                                orderLineResult.ReserveQty += UsableQty;
                                break;

                            case "采购退货出库":
                                returnLineResult.ReserveQty += UsableQty;
                                break;
                            }
                        }
                        break;

                    case false:      //减少库存量
                        result                 = oldReserveResult;
                        result.ReserveQty     -= tempReserveQty;
                        stockResult.UsableQty += tempReserveQty;
                        stockResult.BookedQty -= tempReserveQty;
                        switch (result.SourceBillType)
                        {
                        case "销售出库":
                            orderLineResult.ReserveQty -= tempReserveQty;
                            break;

                        case "采购退货出库":
                            returnLineResult.ReserveQty -= tempReserveQty;
                            break;
                        }

                        break;
                    }  // end of switch
                }   //end of if  else
                    //更改预留表
                this.AddOrUpdate(result);
                //更改库存
                stockBLL.AddOrUpdate(stockResult);
                //更新预留关联单据明细
                switch (result.SourceBillType)
                {
                case "销售出库":
                    orderLineBLL.AddOrUpdate(orderLineResult);
                    break;

                case "采购退货出库":
                    returnLineBLL.AddOrUpdate(returnLineResult);
                    break;
                }    // end of if else
            }
            catch (WarnException exp)
            {
                throw exp;
            }
            catch (System.Exception exp)
            {
                LogInfoBLL.WriteLog(this.SessionInfo, exp);
                throw exp;
            }
            return(true);
        }