protected virtual INCartSplit SyncWithCart(ScanHeader header, decimal?qty)
        {
            INCartSplit cartSplit = CartSplits.Search <INCartSplit.inventoryID, INCartSplit.subItemID, INCartSplit.fromLocationID, INCartSplit.lotSerialNbr>(
                header.InventoryID, header.SubItemID, header.LocationID, string.IsNullOrEmpty(header.LotSerialNbr) ? null : header.LotSerialNbr);

            if (cartSplit == null)
            {
                cartSplit = CartSplits.Insert(new INCartSplit
                {
                    CartID         = header.CartID,
                    InventoryID    = header.InventoryID,
                    SubItemID      = header.SubItemID,
                    LotSerialNbr   = header.LotSerialNbr,
                    ExpireDate     = header.ExpireDate,
                    UOM            = header.UOM,
                    SiteID         = header.SiteID,
                    FromLocationID = header.LocationID,
                    Qty            = qty
                });
            }
            else
            {
                var copy = (INCartSplit)CartSplits.Cache.CreateCopy(cartSplit);
                copy.Qty += qty;
                cartSplit = CartSplits.Update(copy);

                if (cartSplit.Qty == 0)
                {
                    cartSplit = CartSplits.Delete(cartSplit);
                }
            }

            return(cartSplit);
        }
        protected virtual void ConfirmCartIn()
        {
            WMSFlowStatus Implementation()
            {
                WMSFlowStatus status;

                if (!ValidateConfirmation(out status))
                {
                    return(status);
                }

                ScanHeader header        = CurrentHeader;
                bool       isSerialItem  = header.LotSerTrack == INLotSerTrack.SerialNumbered;
                var        userLotSerial = header.LotSerialNbr;

                TScanDocument doc       = SyncWithDocument(header);
                ScanLine      existLine = FindFixedLineFromCart(header);

                if (!SyncWithLines(header, header.Qty, ref existLine, out status))
                {
                    return(status);
                }

                INCartSplit cartSplit = SyncWithCart(header, header.Qty);

                SyncWithDocumentCart(header, existLine, cartSplit, header.Qty);

                Report(Msg.InventoryAdded, LinesView.Cache.GetValueExt <ScanLine.inventoryID>(existLine), header.Qty, header.UOM);

                OnCartInConfirmed();

                return(WMSFlowStatus.Ok.WithPostAction(() => SetQtyOverridable(!isSerialItem)));
            }

            using (var ts = new PXTransactionScope())
            {
                var res = ExecuteAndCompleteFlow(Implementation);
                if (res.IsError == false)
                {
                    ts.Complete();
                }
            }
        }
        protected virtual void SyncWithDocumentCartLine(ScanHeader header, ScanLine line, INCartSplit cartSplit, decimal?qty)
        {
            bool emptyLine = line.Qty.GetValueOrDefault() == 0;

            INRegisterCartLine docCartLine = RegisterCartLines.Search <INRegisterCartLine.lineNbr>(line.LineNbr);

            if (docCartLine == null)
            {
                if (qty <= 0)
                {
                    throw new PXArgumentException(nameof(qty));
                }
                docCartLine = RegisterCartLines.Insert();
                RegisterCartLines.Cache.SetValue <INRegisterCartLine.cartSplitLineNbr>(docCartLine, cartSplit.SplitLineNbr);
            }
            docCartLine      = (INRegisterCartLine)RegisterCartLines.Cache.CreateCopy(docCartLine);
            docCartLine.Qty += qty;
            RegisterCartLines.Cache.Update(docCartLine);

            if (docCartLine.Qty == 0)
            {
                RegisterCartLines.Delete(docCartLine);
            }
        }
        protected override void SyncWithDocumentCart(ScanHeader header, ScanLine line, INCartSplit cartSplit, decimal?qty)
        {
            INRegisterCart registerCart = RegisterCart.Current;

            if (registerCart == null)
            {
                registerCart = RegisterCart.Insert();
            }

            RegisterCart.Cache.SetValue <INRegisterCart.docType>(registerCart, Register.DocType);
            RegisterCart.Cache.SetValue <INRegisterCart.refNbr>(registerCart, Register.RefNbr);

            SyncWithDocumentCartLine(header, line, cartSplit, qty);

            if (IsEmptyCart)
            {
                RegisterCart.Delete(registerCart);
            }
        }
        protected virtual void MoveToCart()
        {
            WMSFlowStatus Implementation()
            {
                WMSFlowStatus status;

                if (!ValidateConfirmation(out status))
                {
                    return(status);
                }

                ScanHeader header       = CurrentHeader;
                bool       isSerialItem = header.LotSerTrack == INLotSerTrack.SerialNumbered;
                decimal?   confirmQty   = header.Qty;

                ScanLine existLine = FindLineFromDocument(header);

                if (existLine == null)
                {
                    return(LineMissingStatus());
                }

                if (!SyncWithLines(CurrentHeader, -confirmQty, ref existLine, out status))
                {
                    return(status);
                }

                HeaderSetter.Set(x => x.LocationID, existLine.LocationID);
                HeaderSetter.Set(x => x.ToLocationID, existLine.LocationID);
                HeaderSetter.Set(x => x.SiteID, existLine.SiteID);
                HeaderSetter.Set(x => x.LotSerialNbr, existLine.LotSerialNbr);
                HeaderSetter.Set(x => x.ReasonCode, existLine.ReasonCode);
                HeaderSetter.Set(x => x.ExpireDate, existLine.ExpireDate);
                HeaderSetter.Set(x => x.SubItemID, existLine.SubItemID);

                //put item to the cart
                existLine = FindFixedLineFromCart(CurrentHeader);
                if (!SyncWithLines(CurrentHeader, confirmQty, ref existLine, out status))
                {
                    return(status);
                }

                INCartSplit cartSplit = SyncWithCart(CurrentHeader, confirmQty);

                SyncWithDocumentCart(CurrentHeader, existLine, cartSplit, confirmQty);

                Report(Msg.InventoryRemoved, LinesView.Cache.GetValueExt <ScanLine.inventoryID>(existLine), confirmQty);

                OnMovedToCart();

                return(WMSFlowStatus.Ok.WithPostAction(() => SetQtyOverridable(!isSerialItem)));
            };
            using (var ts = new PXTransactionScope())
            {
                var res = ExecuteAndCompleteFlow(Implementation);
                if (res.IsError == false)
                {
                    ts.Complete();
                }
            }
        }
 protected virtual void SyncWithDocumentCart(TWMSHeader header, TScanLine scanLine, INCartSplit cartSplit, decimal?qty)
 {
 }
 protected virtual void SyncWithDocumentCart(ScanHeader header, ScanLine line, INCartSplit cartSplit, decimal?qty)
 => SyncWithDocumentCart(HeaderView.Cache.GetMain(header) as TWMSHeader, LinesView.Cache.GetMain(line) as TScanLine, cartSplit, qty);