Codeunit 5815 Undo Sales Shipment Line

Base Application, Microsoft.Sales.History

src/Layers/W1/BaseApp/Sales/History/UndoSalesShipmentLine.Codeunit.al1,135 lines, Copyright (c) Microsoft Corporation. MIT

// ------------------------------------------------------------------------------------------------// Copyright (c) Microsoft Corporation. All rights reserved.// Licensed under the MIT License. See License.txt in the project root for license information.// ------------------------------------------------------------------------------------------------namespace Microsoft.Sales.History;using Microsoft.Assembly.Document;using Microsoft.Assembly.History;using Microsoft.Assembly.Posting;using Microsoft.Foundation.AuditCodes;using Microsoft.Foundation.UOM;using Microsoft.Inventory;using Microsoft.Inventory.Analysis;using Microsoft.Inventory.Costing;using Microsoft.Inventory.Item;using Microsoft.Inventory.Journal;using Microsoft.Inventory.Ledger;using Microsoft.Inventory.Posting;using Microsoft.Inventory.Setup;using Microsoft.Projects.Resources.Journal;using Microsoft.Purchases.History;using Microsoft.Sales.Document;using Microsoft.Utilities;using Microsoft.Warehouse.History;using Microsoft.Warehouse.Journal;/// <summary>/// Reverses posted sales shipment lines by creating corrective inventory and ledger entries./// </summary>codeunit 5815 "Undo Sales Shipment Line"{    Permissions = TableData "Sales Line" = rimd,                  TableData "Sales Shipment Line" = rimd,                  TableData "Item Application Entry" = rmd,                  TableData "Item Entry Relation" = ri;    TableNo = "Sales Shipment Line";    EventSubscriberInstance = Manual;    trigger OnRun()    var        UpdateItemAnalysisView: Codeunit "Update Item Analysis View";        IsHandled: Boolean;        SkipTypeCheck: Boolean;    begin        IsHandled := false;        SkipTypeCheck := false;        OnBeforeOnRun(Rec, IsHandled, SkipTypeCheck, UndoSalesShptLineParams."Hide Dialog");        if IsHandled then            exit;        if not UndoSalesShptLineParams."Hide Dialog" then            if not Confirm(HandleConfirmMessage(Rec)) then                exit;        SalesShipmentLine.Copy(Rec);        Code();        UpdateItemAnalysisView.UpdateAll(0, true);        Rec := SalesShipmentLine;    end;    var        SalesShipmentLine: Record "Sales Shipment Line";        TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary;        TempGlobalItemLedgerEntry: Record "Item Ledger Entry" temporary;        TempGlobalItemEntryRelation: Record "Item Entry Relation" temporary;        UndoSalesShptLineParams: Record "Undo Sales Shpt. Line Params";        UndoPostingManagement: Codeunit "Undo Posting Management";        ItemJnlPostLine: Codeunit "Item Jnl.-Post Line";        WhseUndoQuantity: Codeunit "Whse. Undo Quantity";        ResJnlPostLine: Codeunit "Res. Jnl.-Post Line";        AssemblyPost: Codeunit "Assembly-Post";        UnitOfMeasureManagement: Codeunit "Unit of Measure Management";        ItemsToAdjust: List of [Code[20]];        ATOWindowDialog: Dialog;        NextLineNo: Integer;        IsCalledFromPurchRcptLine: Boolean;#pragma warning disable AA0074        UndoShipmentLinesQst: Label 'Do you really want to undo the selected Shipment lines?';        Text001: Label 'Undo quantity posting...';        Text002: Label 'There is not enough space to insert correction lines.';        Text003: Label 'Checking lines...';        Text005: Label 'This shipment has already been invoiced. Undo Shipment can be applied only to posted, but not invoiced shipments.';#pragma warning disable AA0470        Text055: Label '#1#################################\\Checking Undo Assembly #2###########.';        Text056: Label '#1#################################\\Posting Undo Assembly #2###########.';        Text057: Label '#1#################################\\Finalizing Undo Assembly #2###########.';#pragma warning restore AA0470        Text059: Label '%1 %2 %3', Comment = '%1 = SalesShipmentLine."Document No.". %2 = SalesShipmentLine.FIELDCAPTION("Line No."). %3 = SalesShipmentLine."Line No.". This is used in a progress window.';#pragma warning restore AA0074        AlreadyReversedErr: Label 'This shipment has already been reversed.';        NoLinesToReverseErr: Label 'No lines with a quantity available for reversal were found among the selected lines. Select a line with a quantity that has not already been reversed, and try again.';        InvoiceCancelledQst: Label 'The quantity to undo might differ from the original shipment because the invoice was cancelled. Do you want to proceed with the undo?';    /// <summary>    /// Sets whether the confirmation dialog should be hidden when undoing sales shipment lines.    /// </summary>    /// <param name="NewHideDialog">Specifies whether to hide the confirmation dialog.</param>    procedure SetHideDialog(NewHideDialog: Boolean)    begin        UndoSalesShptLineParams."Hide Dialog" := NewHideDialog;    end;    /// <summary>    /// Sets the parameters for the undo sales shipment line operation.    /// </summary>    /// <param name="NewUndoSalesShptLineParams">Specifies the parameters to use for the undo operation.</param>    procedure SetParameters(var NewUndoSalesShptLineParams: Record "Undo Sales Shpt. Line Params")    begin        UndoSalesShptLineParams := NewUndoSalesShptLineParams;    end;    local procedure "Code"()    var        PostedWhseShipmentLine: Record "Posted Whse. Shipment Line";        SalesLine: Record "Sales Line";        WhseJnlRegisterLine: Codeunit "Whse. Jnl.-Register Line";        WindowDialog: Dialog;        ItemShptEntryNo: Integer;        DocLineNo: Integer;        PostedWhseShptLineFound: Boolean;        IsHandled: Boolean;    begin        Clear(ItemJnlPostLine);        SalesShipmentLine.SetCurrentKey("Item Shpt. Entry No.");        SalesShipmentLine.SetFilter(Quantity, '<>0');        SalesShipmentLine.SetRange(Correction, false);        OnCodeOnAfterSalesShptLineSetFilters(SalesShipmentLine, UndoSalesShptLineParams."Hide Dialog");        if SalesShipmentLine.IsEmpty() then            Error(NoLinesToReverseErr);        SalesShipmentLine.FindFirst();        repeat            if not UndoSalesShptLineParams."Hide Dialog" then                WindowDialog.Open(Text003);            CheckSalesShptLine(SalesShipmentLine);        until SalesShipmentLine.Next() = 0;        OnAfterCheckSalesShipmentLines(SalesShipmentLine, UndoSalesShptLineParams);        BindSubscription(this);        SalesShipmentLine.Find('-');        repeat            OnCodeOnBeforeUndoLoop(SalesShipmentLine);            TempGlobalItemLedgerEntry.Reset();            if not TempGlobalItemLedgerEntry.IsEmpty() then                TempGlobalItemLedgerEntry.DeleteAll();            TempGlobalItemEntryRelation.Reset();            if not TempGlobalItemEntryRelation.IsEmpty() then                TempGlobalItemEntryRelation.DeleteAll();            if not UndoSalesShptLineParams."Hide Dialog" then                WindowDialog.Open(Text001);            IsHandled := false;            OnCodeOnBeforeProcessItemShptEntry(ItemShptEntryNo, DocLineNo, SalesShipmentLine, IsHandled);            if not IsHandled then                if SalesShipmentLine.Type = SalesShipmentLine.Type::Item then begin                    PostedWhseShptLineFound :=                    WhseUndoQuantity.FindPostedWhseShptLine(                        PostedWhseShipmentLine, DATABASE::"Sales Shipment Line", SalesShipmentLine."Document No.",                        DATABASE::"Sales Line", SalesLine."Document Type"::Order.AsInteger(), SalesShipmentLine."Order No.", SalesShipmentLine."Order Line No.");                    Clear(ItemJnlPostLine);                    ItemShptEntryNo := PostItemJnlLine(SalesShipmentLine, DocLineNo);                end else                    DocLineNo := GetCorrectionLineNo(SalesShipmentLine);            InsertNewShipmentLine(SalesShipmentLine, ItemShptEntryNo, DocLineNo);            OnAfterInsertNewShipmentLine(SalesShipmentLine, PostedWhseShipmentLine, PostedWhseShptLineFound, DocLineNo, ItemShptEntryNo);            if PostedWhseShptLineFound then                WhseUndoQuantity.UndoPostedWhseShptLine(PostedWhseShipmentLine);            TempWarehouseJournalLine.SetRange("Source Line No.", SalesShipmentLine."Order Line No.");            WhseUndoQuantity.PostTempWhseJnlLineCache(TempWarehouseJournalLine, WhseJnlRegisterLine);            UndoPostATO(SalesShipmentLine, WhseJnlRegisterLine);            UpdateOrderLine(SalesShipmentLine);            if PostedWhseShptLineFound then                WhseUndoQuantity.UpdateShptSourceDocLines(PostedWhseShipmentLine);            if (SalesShipmentLine."Blanket Order No." <> '') and (SalesShipmentLine."Blanket Order Line No." <> 0) then                UpdateBlanketOrder(SalesShipmentLine);            OnBeforeDeleteRelatedItems(SalesShipmentLine, UndoSalesShptLineParams);            SalesShipmentLine."Quantity Invoiced" := SalesShipmentLine.Quantity;            SalesShipmentLine."Qty. Invoiced (Base)" := SalesShipmentLine."Quantity (Base)";            SalesShipmentLine."Qty. Shipped Not Invoiced" := 0;            SalesShipmentLine.Correction := true;            OnBeforeSalesShptLineModify(SalesShipmentLine);            SalesShipmentLine.Modify();            OnAfterSalesShptLineModify(SalesShipmentLine, DocLineNo, UndoSalesShptLineParams."Hide Dialog");            UndoFinalizePostATO(SalesShipmentLine);        until SalesShipmentLine.Next() = 0;        UnbindSubscription(this);        MakeInventoryAdjustment();        OnAfterCode(SalesShipmentLine);    end;    local procedure RemoveDropShipmentApplicationWithPurchase(SalesShptLine: Record "Sales Shipment Line"; NewSalesShptLine: Record "Sales Shipment Line")    var        ItemLedgerEntry: Record "Item Ledger Entry";        PurchItemLedgerEntryToUndo: Integer;    begin        if not SalesShptLine."Drop Shipment" then            exit;        if ItemLedgerEntry.Get(SalesShptLine."Item Shpt. Entry No.") then begin            PurchItemLedgerEntryToUndo := ItemLedgerEntry."Applies-to Entry";            UnApplyDropShipment(ItemLedgerEntry, NewSalesShptLine, SalesShptLine);        end else begin            ApplyFilterForItemTracking(ItemLedgerEntry, SalesShptLine);            if ItemLedgerEntry.FindSet() then                repeat                    if PurchItemLedgerEntryToUndo = 0 then                        PurchItemLedgerEntryToUndo := ItemLedgerEntry."Applies-to Entry";                    UnApplyDropShipment(ItemLedgerEntry, NewSalesShptLine, SalesShptLine);                until ItemLedgerEntry.Next() = 0;        end;        if not IsCalledFromPurchRcptLine then            UndoPurchaseReceiptLineForDropShipment(PurchItemLedgerEntryToUndo);    end;    local procedure ApplyFilterForItemTracking(var ItemLedgerEntry: Record "Item Ledger Entry"; SalesShptLine: Record "Sales Shipment Line")    begin        ItemLedgerEntry.SetLoadFields("Entry No.", "Document Type", "Document No.", "Document Line No.", "Applies-to Entry", "Drop Shipment", "Lot No.", "Serial No.");        ItemLedgerEntry.SetRange("Document Type", ItemLedgerEntry."Document Type"::"Sales Shipment");        ItemLedgerEntry.SetRange("Document No.", SalesShptLine."Document No.");        ItemLedgerEntry.SetRange("Document Line No.", SalesShptLine."Line No.");        ItemLedgerEntry.SetRange("Drop Shipment", true);    end;    local procedure UnApplyDropShipment(ItemLedgerEntry: Record "Item Ledger Entry"; NewSalesShptLine: Record "Sales Shipment Line"; SalesShptLine: Record "Sales Shipment Line")    var        ItemApplicationEntry: Record "Item Application Entry";        RelevantUndoShipmentLedgerEntryNo: Integer;    begin        RelevantUndoShipmentLedgerEntryNo := FindRelevantNewSalesShptLedgerEntryNo(SalesShptLine, NewSalesShptLine, ItemLedgerEntry);        ItemApplicationEntry.SetBaseLoadFields();        ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No.");        ItemApplicationEntry.SetRange("Inbound Item Entry No.", ItemLedgerEntry."Applies-to Entry");        ItemApplicationEntry.SetRange("Outbound Item Entry No.", ItemLedgerEntry."Entry No.");        OnUnApplyDropShipmentOnBeforeFindItemApplicationEntry(ItemApplicationEntry, ItemLedgerEntry);        if ItemApplicationEntry.FindFirst() then            ItemJnlPostLine.UnApplyDropShipment(ItemApplicationEntry, RelevantUndoShipmentLedgerEntryNo);    end;    local procedure FindRelevantNewSalesShptLedgerEntryNo(SalesShptLine: Record "Sales Shipment Line"; NewSalesShptLine: Record "Sales Shipment Line"; ItemLedgerEntry: Record "Item Ledger Entry"): Integer    var        UndoReceiptLedgerEntry: Record "Item Ledger Entry";    begin        SalesShptLine := SalesShptLine;        if NewSalesShptLine."Item Shpt. Entry No." <> 0 then            exit(NewSalesShptLine."Item Shpt. Entry No.");        UndoReceiptLedgerEntry.SetLoadFields("Entry No.", "Document Type", "Lot No.", "Serial No.", "Drop Shipment", "Applies-to Entry");        if UndoReceiptLedgerEntry.Get(ItemLedgerEntry."Applies-to Entry") then begin            UndoReceiptLedgerEntry.TestField("Document Type", UndoReceiptLedgerEntry."Document Type"::"Purchase Receipt");            UndoReceiptLedgerEntry.TestField("Lot No.", ItemLedgerEntry."Lot No.");            UndoReceiptLedgerEntry.TestField("Serial No.", ItemLedgerEntry."Serial No.");            UndoReceiptLedgerEntry.TestField("Drop Shipment", true);            exit(UndoReceiptLedgerEntry."Entry No.");        end;        exit(0);    end;    local procedure UndoPurchaseReceiptLineForDropShipment(ReceiptItemLedgerEntryNo: Integer)    var        ItemLedgerEntry: Record "Item Ledger Entry";        PurchaseReceiptLine: Record "Purch. Rcpt. Line";        UndoPurchaseReceiptLine: Codeunit "Undo Purchase Receipt Line";    begin        ItemLedgerEntry.Get(ReceiptItemLedgerEntryNo);        ItemLedgerEntry.TestField("Drop Shipment", true);        PurchaseReceiptLine.SetRange("Document No.", ItemLedgerEntry."Document No.");        PurchaseReceiptLine.SetRange("Line No.", ItemLedgerEntry."Document Line No.");        if (ItemLedgerEntry."Lot No." = '') and (ItemLedgerEntry."Serial No." = '') then            PurchaseReceiptLine.SetRange("Item Rcpt. Entry No.", ItemLedgerEntry."Entry No.");        PurchaseReceiptLine.FindFirst();        UndoPurchaseReceiptLine.SetHideDialog(true);        UndoPurchaseReceiptLine.IsUndoSalesShipmentLineForDropShipment(true);        UndoPurchaseReceiptLine.Run(PurchaseReceiptLine)    end;    local procedure CheckSalesShptLine(SalesShipmentLine2: Record "Sales Shipment Line")    var        TempItemLedgerEntry: Record "Item Ledger Entry" temporary;        IsHandled: Boolean;        SkipTestFields: Boolean;        SkipUndoPosting: Boolean;        SkipUndoInitPostATO: Boolean;    begin        IsHandled := false;        OnBeforeCheckSalesShptLine(SalesShipmentLine2, IsHandled, SkipTestFields, SkipUndoPosting, SkipUndoInitPostATO);        if not IsHandled then begin            if not SkipTestFields then begin                if SalesShipmentLine2.Correction then                    Error(AlreadyReversedErr);                IsHandled := false;                OnCheckSalesShptLineOnBeforeHasInvoicedNotReturnedQuantity(SalesShipmentLine2, IsHandled);                if not IsHandled then                    if SalesShipmentLine2."Qty. Shipped Not Invoiced" <> SalesShipmentLine2.Quantity then                        if HasInvoicedNotReturnedQuantity(SalesShipmentLine2) then                            Error(Text005);            end;            if SalesShipmentLine2.Type = SalesShipmentLine2.Type::Item then begin                if not SkipUndoPosting then begin                    UndoPostingManagement.TestSalesShptLine(SalesShipmentLine2);                    IsHandled := false;                    OnCheckSalesShptLineOnBeforeCollectItemLedgEntries(SalesShipmentLine2, TempItemLedgerEntry, IsHandled);                    if not IsHandled then                        UndoPostingManagement.CollectItemLedgEntries(                            TempItemLedgerEntry, DATABASE::"Sales Shipment Line", SalesShipmentLine2."Document No.", SalesShipmentLine2."Line No.", SalesShipmentLine2."Quantity (Base)", SalesShipmentLine2."Item Shpt. Entry No.");                    UndoPostingManagement.CheckItemLedgEntries(TempItemLedgerEntry, SalesShipmentLine2."Line No.", SalesShipmentLine2."Qty. Shipped Not Invoiced" <> SalesShipmentLine2.Quantity);                end;                if not SkipUndoInitPostATO then                    UndoInitPostATO(SalesShipmentLine2);            end;        end;        OnAfterCheckSalesShptLine(SalesShipmentLine2, TempItemLedgerEntry);    end;    /// <summary>    /// Gets the line number to use for the correction line when undoing a sales shipment line.    /// </summary>    /// <param name="SalesShipmentLine2">Specifies the sales shipment line being undone.</param>    /// <returns>The line number for the correction line.</returns>    procedure GetCorrectionLineNo(SalesShipmentLine2: Record "Sales Shipment Line") Result: Integer;    var        SalesShipmentLine3: Record "Sales Shipment Line";        LineSpacing: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetCorrectionLineNo(SalesShipmentLine2, Result, IsHandled);        if IsHandled then            exit(Result);        SalesShipmentLine3.SetRange("Document No.", SalesShipmentLine2."Document No.");        SalesShipmentLine3."Document No." := SalesShipmentLine2."Document No.";        SalesShipmentLine3."Line No." := SalesShipmentLine2."Line No.";        SalesShipmentLine3.Find('=');        if SalesShipmentLine3.Find('>') then begin            LineSpacing := (SalesShipmentLine3."Line No." - SalesShipmentLine2."Line No.") div 2;            if LineSpacing = 0 then                Error(Text002);        end else            LineSpacing := 10000;        Result := SalesShipmentLine2."Line No." + LineSpacing;        OnAfterGetCorrectionLineNo(SalesShipmentLine2, Result);    end;    local procedure PostItemJnlLine(SalesShipmentLine2: Record "Sales Shipment Line"; var DocLineNo: Integer): Integer    var        ItemJournalLine: Record "Item Journal Line";        SalesLine: Record "Sales Line";        SalesShipmentHeader: Record "Sales Shipment Header";        SourceCodeSetup: Record "Source Code Setup";        TempApplyToItemLedgerEntry: Record "Item Ledger Entry" temporary;        ItemLedgerEntryNotInvoiced: Record "Item Ledger Entry";        ItemLedgEntryNo: Integer;        RemQtyBase: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemJnlLine(            SalesShipmentLine2, DocLineNo, ItemLedgEntryNo, IsHandled, TempGlobalItemLedgerEntry, TempGlobalItemEntryRelation, TempWarehouseJournalLine, NextLineNo);        if IsHandled then            exit(ItemLedgEntryNo);        DocLineNo := GetCorrectionLineNo(SalesShipmentLine2);        SourceCodeSetup.Get();        SalesShipmentHeader.Get(SalesShipmentLine2."Document No.");        ItemJournalLine.Init();        ItemJournalLine."Entry Type" := ItemJournalLine."Entry Type"::Sale;        ItemJournalLine."Item No." := SalesShipmentLine2."No.";        ItemJournalLine."Posting Date" := SalesShipmentHeader."Posting Date";        ItemJournalLine."Document No." := SalesShipmentLine2."Document No.";        ItemJournalLine."Document Line No." := DocLineNo;        ItemJournalLine."Document Type" := ItemJournalLine."Document Type"::"Sales Shipment";        ItemJournalLine."Gen. Bus. Posting Group" := SalesShipmentLine2."Gen. Bus. Posting Group";        ItemJournalLine."Gen. Prod. Posting Group" := SalesShipmentLine2."Gen. Prod. Posting Group";        ItemJournalLine."Location Code" := SalesShipmentLine2."Location Code";        ItemJournalLine."Source Code" := SourceCodeSetup.Sales;        ItemJournalLine.Correction := true;        ItemJournalLine."Variant Code" := SalesShipmentLine2."Variant Code";        ItemJournalLine."Bin Code" := SalesShipmentLine2."Bin Code";        ItemJournalLine."Document Date" := SalesShipmentHeader."Document Date";        ItemJournalLine."Unit of Measure Code" := SalesShipmentLine2."Unit of Measure Code";        ItemJournalLine.Description := SalesShipmentLine2.Description;        ItemJournalLine."Drop Shipment" := SalesShipmentLine2."Drop Shipment";        OnAfterCopyItemJnlLineFromSalesShpt(ItemJournalLine, SalesShipmentHeader, SalesShipmentLine2, TempWarehouseJournalLine, WhseUndoQuantity, ItemLedgEntryNo, NextLineNo, TempGlobalItemLedgerEntry, TempGlobalItemEntryRelation, IsHandled);        if IsHandled then            exit(ItemLedgEntryNo);        UndoPostingManagement.CollectItemLedgEntries(            TempApplyToItemLedgerEntry, DATABASE::"Sales Shipment Line", SalesShipmentLine2."Document No.", SalesShipmentLine2."Line No.", SalesShipmentLine2."Quantity (Base)", SalesShipmentLine2."Item Shpt. Entry No.");        if (SalesShipmentLine2."Qty. Shipped Not Invoiced" = SalesShipmentLine2.Quantity) or           not UndoPostingManagement.AreAllItemEntriesCompletelyInvoiced(TempApplyToItemLedgerEntry)        then            WhseUndoQuantity.InsertTempWhseJnlLine(                ItemJournalLine,                DATABASE::"Sales Line", SalesLine."Document Type"::Order.AsInteger(), SalesShipmentLine2."Order No.", SalesShipmentLine2."Order Line No.",                TempWarehouseJournalLine."Reference Document"::"Posted Shipment".AsInteger(), TempWarehouseJournalLine, NextLineNo);        OnPostItemJnlLineOnAfterInsertTempWhseJnlLine(SalesShipmentLine2, ItemJournalLine, TempWarehouseJournalLine, NextLineNo);        if GetInvoicedShptEntries(SalesShipmentLine2, ItemLedgerEntryNotInvoiced) then begin            RemQtyBase := -(SalesShipmentLine2."Quantity (Base)" - SalesShipmentLine2."Qty. Invoiced (Base)");            OnPostItemJnlLineOnAfterCalcRemQtyBase(RemQtyBase, ItemJournalLine, SalesShipmentLine2, ItemLedgerEntryNotInvoiced);            repeat                ItemJournalLine."Applies-to Entry" := ItemLedgerEntryNotInvoiced."Entry No.";                ItemJournalLine.Quantity := ItemLedgerEntryNotInvoiced.Quantity;                ItemJournalLine."Quantity (Base)" := ItemLedgerEntryNotInvoiced.Quantity;                IsHandled := false;                OnPostItemJnlLineOnBeforeRunItemJnlPostLine(ItemJournalLine, ItemLedgerEntryNotInvoiced, SalesShipmentLine2, SalesShipmentHeader, IsHandled);                if not IsHandled then                    ItemJnlPostLine.Run(ItemJournalLine);                OnPostItemJnlLineOnAfterRunItemJnlPostLine(ItemJournalLine, SalesShipmentLine2, SalesShipmentHeader, ItemJnlPostLine);                RemQtyBase -= ItemJournalLine.Quantity;                if ItemLedgerEntryNotInvoiced.Next() = 0 then;            until (RemQtyBase = 0);            OnItemJnlPostLineOnAfterGetInvoicedShptEntriesOnBeforeExit(ItemJournalLine, SalesShipmentLine2);            exit(ItemJournalLine."Item Shpt. Entry No.");        end;        UndoPostingManagement.PostItemJnlLineAppliedToList(            ItemJournalLine, TempApplyToItemLedgerEntry, SalesShipmentLine2.Quantity - SalesShipmentLine2."Quantity Invoiced", SalesShipmentLine2."Quantity (Base)" - SalesShipmentLine2."Qty. Invoiced (Base)", TempGlobalItemLedgerEntry, TempGlobalItemEntryRelation, SalesShipmentLine2."Qty. Shipped Not Invoiced" <> SalesShipmentLine2.Quantity);        OnAfterPostItemJnlLine(ItemJournalLine, SalesShipmentLine2);        exit(0); // "Item Shpt. Entry No."    end;    local procedure InsertNewShipmentLine(OldSalesShipmentLine: Record "Sales Shipment Line"; ItemShptEntryNo: Integer; DocLineNo: Integer)    var        NewSalesShipmentLine: Record "Sales Shipment Line";    begin        NewSalesShipmentLine.Init();        NewSalesShipmentLine.Copy(OldSalesShipmentLine);        NewSalesShipmentLine."Line No." := DocLineNo;        NewSalesShipmentLine."Appl.-from Item Entry" := OldSalesShipmentLine."Item Shpt. Entry No.";        NewSalesShipmentLine."Item Shpt. Entry No." := ItemShptEntryNo;        NewSalesShipmentLine.Quantity := -OldSalesShipmentLine.Quantity;        NewSalesShipmentLine."Qty. Shipped Not Invoiced" := 0;        NewSalesShipmentLine."Quantity (Base)" := -OldSalesShipmentLine."Quantity (Base)";        NewSalesShipmentLine."Quantity Invoiced" := NewSalesShipmentLine.Quantity;        NewSalesShipmentLine."Qty. Invoiced (Base)" := NewSalesShipmentLine."Quantity (Base)";        NewSalesShipmentLine.Correction := true;        NewSalesShipmentLine."Dimension Set ID" := OldSalesShipmentLine."Dimension Set ID";        OnBeforeNewSalesShptLineInsert(NewSalesShipmentLine, OldSalesShipmentLine);        NewSalesShipmentLine.Insert();        OnAfterNewSalesShptLineInsert(NewSalesShipmentLine, OldSalesShipmentLine);        RemoveDropShipmentApplicationWithPurchase(OldSalesShipmentLine, NewSalesShipmentLine);        InsertItemEntryRelation(TempGlobalItemEntryRelation, NewSalesShipmentLine);    end;    /// <summary>    /// Updates the related sales order line after undoing a sales shipment line.    /// </summary>    /// <param name="SalesShipmentLine2">Specifies the sales shipment line that was undone.</param>    procedure UpdateOrderLine(SalesShipmentLine2: Record "Sales Shipment Line")    var        SalesLine: Record "Sales Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateOrderLine(SalesShipmentLine2, IsHandled, TempGlobalItemLedgerEntry);        if IsHandled then            exit;        SalesLine.Get(SalesLine."Document Type"::Order, SalesShipmentLine2."Order No.", SalesShipmentLine2."Order Line No.");        OnUpdateOrderLineOnBeforeUpdateSalesLine(SalesShipmentLine2, SalesLine);        UndoPostingManagement.UpdateSalesLine(            SalesLine, SalesShipmentLine2.Quantity - SalesShipmentLine2."Quantity Invoiced",            SalesShipmentLine2."Quantity (Base)" - SalesShipmentLine2."Qty. Invoiced (Base)", TempGlobalItemLedgerEntry);        OnAfterUpdateSalesLine(SalesLine, SalesShipmentLine2);    end;    /// <summary>    /// Updates the related blanket sales order line after undoing a sales shipment line.    /// </summary>    /// <param name="SalesShipmentLine2">Specifies the sales shipment line that was undone.</param>    procedure UpdateBlanketOrder(SalesShipmentLine2: Record "Sales Shipment Line")    var        BlanketOrderSalesLine: Record "Sales Line";        xBlanketOrderSalesLine: Record "Sales Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateBlanketOrder(SalesShipmentLine2, IsHandled);        if IsHandled then            exit;        if BlanketOrderSalesLine.Get(                 BlanketOrderSalesLine."Document Type"::"Blanket Order", SalesShipmentLine2."Blanket Order No.", SalesShipmentLine2."Blanket Order Line No.")        then begin            BlanketOrderSalesLine.TestField(Type, SalesShipmentLine2.Type);            BlanketOrderSalesLine.TestField("No.", SalesShipmentLine2."No.");            BlanketOrderSalesLine.TestField("Sell-to Customer No.", SalesShipmentLine2."Sell-to Customer No.");            xBlanketOrderSalesLine := BlanketOrderSalesLine;            if BlanketOrderSalesLine."Qty. per Unit of Measure" = SalesShipmentLine2."Qty. per Unit of Measure" then                BlanketOrderSalesLine."Quantity Shipped" := BlanketOrderSalesLine."Quantity Shipped" - SalesShipmentLine2.Quantity            else                BlanketOrderSalesLine."Quantity Shipped" :=                  BlanketOrderSalesLine."Quantity Shipped" -                  Round(                    SalesShipmentLine2."Qty. per Unit of Measure" / BlanketOrderSalesLine."Qty. per Unit of Measure" * SalesShipmentLine2.Quantity,                    UnitOfMeasureManagement.QtyRndPrecision());            BlanketOrderSalesLine."Qty. Shipped (Base)" := BlanketOrderSalesLine."Qty. Shipped (Base)" - SalesShipmentLine2."Quantity (Base)";            OnBeforeBlanketOrderInitOutstanding(BlanketOrderSalesLine, SalesShipmentLine2);            BlanketOrderSalesLine.InitOutstanding();            BlanketOrderSalesLine.Modify();            AssemblyPost.UpdateBlanketATO(xBlanketOrderSalesLine, BlanketOrderSalesLine);        end;    end;    local procedure InsertItemEntryRelation(var TempItemEntryRelation: Record "Item Entry Relation" temporary; NewSalesShipmentLine: Record "Sales Shipment Line")    var        ItemEntryRelation: Record "Item Entry Relation";    begin        if TempItemEntryRelation.Find('-') then            repeat                ItemEntryRelation := TempItemEntryRelation;                ItemEntryRelation.TransferFieldsSalesShptLine(NewSalesShipmentLine);                ItemEntryRelation.Insert();            until TempItemEntryRelation.Next() = 0;    end;    local procedure UndoInitPostATO(var SalesShipmentLine2: Record "Sales Shipment Line")    var        PostedAssemblyHeader: Record "Posted Assembly Header";    begin        if SalesShipmentLine2.AsmToShipmentExists(PostedAssemblyHeader) then begin            OpenATOProgressWindow(Text055, SalesShipmentLine2, PostedAssemblyHeader);            AssemblyPost.UndoInitPostATO(PostedAssemblyHeader);            ATOWindowDialog.Close();        end;    end;    local procedure UndoPostATO(var SalesShipmentLine2: Record "Sales Shipment Line"; var WhseJnlRegisterLine: Codeunit "Whse. Jnl.-Register Line")    var        PostedAssemblyHeader: Record "Posted Assembly Header";    begin        if SalesShipmentLine2.AsmToShipmentExists(PostedAssemblyHeader) then begin            OpenATOProgressWindow(Text056, SalesShipmentLine2, PostedAssemblyHeader);            AssemblyPost.UndoPostATO(PostedAssemblyHeader, ItemJnlPostLine, ResJnlPostLine, WhseJnlRegisterLine);            ATOWindowDialog.Close();        end;    end;    local procedure UndoFinalizePostATO(var SalesShipmentLine2: Record "Sales Shipment Line")    var        PostedAssemblyHeader: Record "Posted Assembly Header";    begin        if SalesShipmentLine2.AsmToShipmentExists(PostedAssemblyHeader) then begin            OpenATOProgressWindow(Text057, SalesShipmentLine2, PostedAssemblyHeader);            AssemblyPost.UndoFinalizePostATO(PostedAssemblyHeader);            SynchronizeATO(SalesShipmentLine2);            ATOWindowDialog.Close();        end;    end;    local procedure SynchronizeATO(var SalesShipmentLine2: Record "Sales Shipment Line")    var        SalesLine: Record "Sales Line";        AssemblyHeader: Record "Assembly Header";    begin        SalesLine.Get(Enum::"Sales Document Type"::Order, SalesShipmentLine2."Order No.", SalesShipmentLine2."Order Line No.");        if SalesLine.AsmToOrderExists(AssemblyHeader) and (AssemblyHeader.Status = AssemblyHeader.Status::Released) then begin            AssemblyHeader.Status := AssemblyHeader.Status::Open;            AssemblyHeader.Modify();            SalesLine.AutoAsmToOrder();            AssemblyHeader.Status := AssemblyHeader.Status::Released;            AssemblyHeader.Modify();        end else            SalesLine.AutoAsmToOrder();        OnSynchronizeATOOnBeforeModify(SalesLine);        SalesLine.Modify(true);    end;    local procedure OpenATOProgressWindow(State: Text[250]; SalesShipmentLine2: Record "Sales Shipment Line"; PostedAssemblyHeader: Record "Posted Assembly Header")    begin        ATOWindowDialog.Open(State);        ATOWindowDialog.Update(1,          StrSubstNo(Text059,            SalesShipmentLine2."Document No.", SalesShipmentLine2.FieldCaption("Line No."), SalesShipmentLine2."Line No."));        ATOWindowDialog.Update(2, PostedAssemblyHeader."No.");    end;    /// <summary>    /// Gets the item ledger entries for shipments that have been invoiced but not completely invoiced.    /// </summary>    /// <param name="SalesShipmentLine2">Specifies the sales shipment line to search for.</param>    /// <param name="ItemLedgerEntry">Returns the item ledger entries found.</param>    /// <returns>True if any item ledger entries were found, otherwise false.</returns>    procedure GetInvoicedShptEntries(SalesShipmentLine2: Record "Sales Shipment Line"; var ItemLedgerEntry: Record "Item Ledger Entry"): Boolean    begin        ItemLedgerEntry.SetCurrentKey("Document No.", "Document Type", "Document Line No.");        ItemLedgerEntry.SetRange("Document Type", ItemLedgerEntry."Document Type"::"Sales Shipment");        ItemLedgerEntry.SetRange("Document No.", SalesShipmentLine2."Document No.");        ItemLedgerEntry.SetRange("Document Line No.", SalesShipmentLine2."Line No.");        ItemLedgerEntry.SetTrackingFilterBlank();        ItemLedgerEntry.SetRange("Completely Invoiced", false);        OnGetInvoicedShptEntriesOnAfterSetFilters(ItemLedgerEntry, SalesShipmentLine);        exit(ItemLedgerEntry.FindSet());    end;    local procedure HasInvoicedNotReturnedQuantity(SalesShipmentLine2: Record "Sales Shipment Line"): Boolean    var        ItemLedgerEntry: Record "Item Ledger Entry";        ReturnedInvoicedItemLedgerEntry: Record "Item Ledger Entry";        ItemApplicationEntry: Record "Item Application Entry";        SalesInvoiceHeader: Record "Sales Invoice Header";        SalesInvoiceLine: Record "Sales Invoice Line";        InvoicedQuantity: Decimal;        ReturnedInvoicedQuantity: Decimal;    begin        if SalesShipmentLine2.Type = SalesShipmentLine2.Type::Item then begin            ItemLedgerEntry.SetRange("Document Type", ItemLedgerEntry."Document Type"::"Sales Shipment");            ItemLedgerEntry.SetRange("Document No.", SalesShipmentLine2."Document No.");            ItemLedgerEntry.SetRange("Document Line No.", SalesShipmentLine2."Line No.");            ItemLedgerEntry.FindSet();            repeat                InvoicedQuantity += ItemLedgerEntry."Invoiced Quantity";                if ItemApplicationEntry.AppliedInbndEntryExists(ItemLedgerEntry."Entry No.", false) then                    repeat                        if ItemApplicationEntry."Item Ledger Entry No." = ItemApplicationEntry."Inbound Item Entry No." then begin                            ReturnedInvoicedItemLedgerEntry.Get(ItemApplicationEntry."Item Ledger Entry No.");                            if IsCancelled(ReturnedInvoicedItemLedgerEntry) then                                ReturnedInvoicedQuantity += ReturnedInvoicedItemLedgerEntry."Invoiced Quantity";                        end;                    until ItemApplicationEntry.Next() = 0;            until ItemLedgerEntry.Next() = 0;            exit(InvoicedQuantity + ReturnedInvoicedQuantity <> 0);        end else begin            SalesInvoiceLine.SetRange("Order No.", SalesShipmentLine2."Order No.");            SalesInvoiceLine.SetRange("Order Line No.", SalesShipmentLine2."Order Line No.");            if SalesInvoiceLine.FindSet() then                repeat                    SalesInvoiceHeader.Get(SalesInvoiceLine."Document No.");                    if not IsSalesInvoiceCancelled(SalesInvoiceHeader) then                        exit(true);                until SalesInvoiceLine.Next() = 0;            exit(false);        end;    end;    local procedure IsCancelled(ItemLedgerEntry: Record "Item Ledger Entry"): Boolean    var        CancelledDocument: Record "Cancelled Document";        ReturnReceiptHeader: Record "Return Receipt Header";        SalesCrMemoHeader: Record "Sales Cr.Memo Header";    begin        case ItemLedgerEntry."Document Type" of            ItemLedgerEntry."Document Type"::"Sales Return Receipt":                begin                    ReturnReceiptHeader.Get(ItemLedgerEntry."Document No.");                    if ReturnReceiptHeader."Applies-to Doc. Type" = ReturnReceiptHeader."Applies-to Doc. Type"::Invoice then                        exit(CancelledDocument.Get(Database::"Sales Invoice Header", ReturnReceiptHeader."Applies-to Doc. No."));                end;            ItemLedgerEntry."Document Type"::"Sales Credit Memo":                begin                    SalesCrMemoHeader.Get(ItemLedgerEntry."Document No.");                    if SalesCrMemoHeader."Applies-to Doc. Type" = SalesCrMemoHeader."Applies-to Doc. Type"::Invoice then                        exit(CancelledDocument.Get(Database::"Sales Invoice Header", SalesCrMemoHeader."Applies-to Doc. No."));                end;        end;        exit(false);    end;    local procedure IsSalesInvoiceCancelled(var SalesInvoiceHeader: Record "Sales Invoice Header") Result: Boolean    begin        SalesInvoiceHeader.CalcFields(Cancelled);        Result := SalesInvoiceHeader.Cancelled;        OnAfterIsSalesInvoiceCancelled(SalesInvoiceHeader, Result);    end;    local procedure MakeInventoryAdjustment()    var        InventoryAdjustmentHandler: Codeunit "Inventory Adjustment Handler";    begin        InventoryAdjustmentHandler.SetJobUpdateProperties(true);        InventoryAdjustmentHandler.MakeAutomaticInventoryAdjustment(ItemsToAdjust);    end;    local procedure IsCancelledSalesInvoice(OrderNo: Code[20]): Boolean    var        SalesInvoiceHeader: Record "Sales Invoice Header";    begin        SalesInvoiceHeader.SetRange("Order No.", OrderNo);        SalesInvoiceHeader.SetRange(Cancelled, true);        exit(not SalesInvoiceHeader.IsEmpty());    end;    local procedure HandleConfirmMessage(SalesShipmentLine2: Record "Sales Shipment Line"): Text    begin        if IsCancelledSalesInvoice(SalesShipmentLine2."Order No.") then            exit(InvoiceCancelledQst);        exit(UndoShipmentLinesQst);    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Item Jnl.-Post Line", 'OnSetItemAdjmtPropertiesOnBeforeCheckModifyItem', '', false, false)]    local procedure OnSetItemAdjmtPropertiesOnBeforeCheckModifyItem(var Item2: Record Item)    var        InventorySetup: Record "Inventory Setup";    begin        if InventorySetup.UseLegacyPosting() then            exit;        if not ItemsToAdjust.Contains(Item2."No.") then            ItemsToAdjust.Add(Item2."No.");    end;    procedure SetCalledFromUndoPurchaseReceiptLine(NewCalledFromPurchRcptLine: Boolean)    begin        IsCalledFromPurchRcptLine := NewCalledFromPurchRcptLine;    end;    /// <summary>    /// Raised after the undo sales shipment line process is completed.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line that was undone.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCode(var SalesShipmentLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised after copying the item journal line from the sales shipment during the undo process.    /// </summary>    /// <param name="ItemJournalLine">The item journal line being created.</param>    /// <param name="SalesShipmentHeader">The sales shipment header.</param>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    /// <param name="TempWhseJnlLine">Temporary warehouse journal line.</param>    /// <param name="WhseUndoQty">The warehouse undo quantity codeunit.</param>    /// <param name="ItemLedgEntryNo">The item ledger entry number.</param>    /// <param name="NextLineNo">The next line number.</param>    /// <param name="TempGlobalItemLedgerEntry">Temporary item ledger entry.</param>    /// <param name="TempGlobalItemEntryRelation">Temporary item entry relation.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCopyItemJnlLineFromSalesShpt(var ItemJournalLine: Record "Item Journal Line"; SalesShipmentHeader: Record "Sales Shipment Header"; SalesShipmentLine: Record "Sales Shipment Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; var WhseUndoQty: Codeunit "Whse. Undo Quantity"; var ItemLedgEntryNo: Integer; var NextLineNo: Integer; var TempGlobalItemLedgerEntry: Record "Item Ledger Entry" temporary; var TempGlobalItemEntryRelation: Record "Item Entry Relation" temporary; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised after validating that the sales shipment line can be undone.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line being validated.</param>    /// <param name="TempItemLedgEntry">Temporary item ledger entries associated with the line.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckSalesShptLine(var SalesShptLine: Record "Sales Shipment Line"; var TempItemLedgEntry: Record "Item Ledger Entry" temporary)    begin    end;    /// <summary>    /// Raised after inserting a new correction sales shipment line during the undo process.    /// </summary>    /// <param name="NewSalesShipmentLine">The newly created correction shipment line.</param>    /// <param name="OldSalesShipmentLine">The original shipment line being undone.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterNewSalesShptLineInsert(var NewSalesShipmentLine: Record "Sales Shipment Line"; OldSalesShipmentLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised after modifying the original sales shipment line during the undo process.    /// </summary>    /// <param name="SalesShptLine">The modified sales shipment line.</param>    /// <param name="DocLineNo">The document line number of the correction line.</param>    /// <param name="HideDialog">Indicates whether dialog messages are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSalesShptLineModify(var SalesShptLine: Record "Sales Shipment Line"; DocLineNo: Integer; HideDialog: Boolean)    begin    end;    /// <summary>    /// Raised after calculating the correction line number for the undo shipment line.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    /// <param name="Result">The calculated correction line number.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterGetCorrectionLineNo(SalesShipmentLine: Record "Sales Shipment Line"; var Result: Integer)    begin    end;    /// <summary>    /// Raised after updating the related sales order line during the undo shipment process.    /// </summary>    /// <param name="SalesLine">The updated sales order line.</param>    /// <param name="SalesShptLine">The sales shipment line being undone.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateSalesLine(var SalesLine: Record "Sales Line"; var SalesShptLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised before initializing outstanding quantities on the blanket order line during undo.    /// </summary>    /// <param name="BlanketOrderSalesLine">The blanket order line being updated.</param>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeBlanketOrderInitOutstanding(var BlanketOrderSalesLine: Record "Sales Line"; SalesShipmentLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised before calculating the correction line number for the undo shipment line.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    /// <param name="Result">The correction line number to use.</param>    /// <param name="IsHandled">Set to true to skip default line number calculation.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetCorrectionLineNo(SalesShipmentLine: Record "Sales Shipment Line"; var Result: Integer; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before validating that the sales shipment line can be undone.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line to validate.</param>    /// <param name="IsHandled">Set to true to skip default validation.</param>    /// <param name="SkipTestFields">Set to true to skip field validations.</param>    /// <param name="SkipUndoPosting">Set to true to skip undo posting validations.</param>    /// <param name="SkipUndoInitPostATO">Set to true to skip assemble-to-order initialization.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckSalesShptLine(var SalesShipmentLine: Record "Sales Shipment Line"; var IsHandled: Boolean; var SkipTestFields: Boolean; var SkipUndoPosting: Boolean; var SkipUndoInitPostATO: Boolean)    begin    end;    /// <summary>    /// Raised after inserting a new correction shipment line during the undo process.    /// </summary>    /// <param name="SalesShipmentLine">The original sales shipment line.</param>    /// <param name="PostedWhseShipmentLine">The posted warehouse shipment line if applicable.</param>    /// <param name="PostedWhseShptLineFound">Indicates whether a posted warehouse shipment line was found.</param>    /// <param name="DocLineNo">The correction document line number.</param>    /// <param name="ItemShptEntryNo">The item shipment entry number.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInsertNewShipmentLine(var SalesShipmentLine: Record "Sales Shipment Line"; var PostedWhseShipmentLine: Record "Posted Whse. Shipment Line"; var PostedWhseShptLineFound: Boolean; DocLineNo: Integer; ItemShptEntryNo: Integer)    begin    end;    /// <summary>    /// Raised before the undo sales shipment line process begins.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line to undo.</param>    /// <param name="IsHandled">Set to true to skip default undo processing.</param>    /// <param name="SkipTypeCheck">Set to true to skip line type validation.</param>    /// <param name="HideDialog">Indicates whether dialog messages should be hidden.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeOnRun(var SalesShipmentLine: Record "Sales Shipment Line"; var IsHandled: Boolean; var SkipTypeCheck: Boolean; var HideDialog: Boolean)    begin    end;    /// <summary>    /// Raised before inserting a new correction sales shipment line during the undo process.    /// </summary>    /// <param name="NewSalesShipmentLine">The correction shipment line to be inserted.</param>    /// <param name="OldSalesShipmentLine">The original shipment line being undone.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeNewSalesShptLineInsert(var NewSalesShipmentLine: Record "Sales Shipment Line"; OldSalesShipmentLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised before posting the item journal line during the undo shipment process.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    /// <param name="DocLineNo">The document line number for the correction.</param>    /// <param name="ItemLedgEntryNo">The item ledger entry number.</param>    /// <param name="IsHandled">Set to true to skip default item journal posting.</param>    /// <param name="TempGlobalItemLedgEntry">Temporary item ledger entry.</param>    /// <param name="TempGlobalItemEntryRelation">Temporary item entry relation.</param>    /// <param name="TempWhseJnlLine">Temporary warehouse journal line.</param>    /// <param name="NextLineNo">The next line number.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemJnlLine(var SalesShipmentLine: Record "Sales Shipment Line"; var DocLineNo: Integer; var ItemLedgEntryNo: Integer; var IsHandled: Boolean; var TempGlobalItemLedgEntry: Record "Item Ledger Entry" temporary; var TempGlobalItemEntryRelation: Record "Item Entry Relation" temporary; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; var NextLineNo: Integer)    begin    end;    /// <summary>    /// Raised before modifying the original sales shipment line during the undo process.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line to be modified.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSalesShptLineModify(var SalesShptLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised before updating the blanket order line during the undo shipment process.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line being undone.</param>    /// <param name="IsHandled">Set to true to skip default blanket order update.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateBlanketOrder(var SalesShptLine: Record "Sales Shipment Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before updating the sales order line during the undo shipment process.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line being undone.</param>    /// <param name="IsHandled">Set to true to skip default order line update.</param>    /// <param name="TempGlobalItemLedgEntry">Temporary item ledger entries.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateOrderLine(var SalesShptLine: Record "Sales Shipment Line"; var IsHandled: Boolean; var TempGlobalItemLedgEntry: Record "Item Ledger Entry" temporary)    begin    end;    /// <summary>    /// Raised before starting the undo loop for each sales shipment line.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line about to be processed.</param>    [IntegrationEvent(false, false)]    local procedure OnCodeOnBeforeUndoLoop(var SalesShptLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised after setting filters on the sales shipment lines to process.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line with applied filters.</param>    /// <param name="HideDialog">Indicates whether dialog messages should be hidden.</param>    [IntegrationEvent(false, false)]    local procedure OnCodeOnAfterSalesShptLineSetFilters(var SalesShptLine: Record "Sales Shipment Line"; HideDialog: Boolean)    begin    end;    /// <summary>    /// Raised after inserting a temporary warehouse journal line during item journal posting.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line being undone.</param>    /// <param name="ItemJnlLine">The item journal line being posted.</param>    /// <param name="TempWhseJnlLine">Temporary warehouse journal line.</param>    /// <param name="NextLineNo">The next line number.</param>    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterInsertTempWhseJnlLine(SalesShptLine: Record "Sales Shipment Line"; var ItemJnlLine: Record "Item Journal Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; var NextLineNo: Integer)    begin    end;    /// <summary>    /// Raised after running the item journal post line during the undo shipment process.    /// </summary>    /// <param name="ItemJnlLine">The posted item journal line.</param>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    /// <param name="SalesShipmentHeader">The sales shipment header.</param>    /// <param name="ItemJnlPostLine">The item journal post line codeunit.</param>    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterRunItemJnlPostLine(var ItemJnlLine: Record "Item Journal Line"; var SalesShipmentLine: Record "Sales Shipment Line"; var SalesShipmentHeader: Record "Sales Shipment Header"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line")    begin    end;    /// <summary>    /// Raised before running the item journal post line during the undo shipment process.    /// </summary>    /// <param name="ItemJnlLine">The item journal line to be posted.</param>    /// <param name="ItemLedgEntryNotInvoiced">The item ledger entry not invoiced.</param>    /// <param name="SalesShptLine">The sales shipment line being undone.</param>    /// <param name="SalesShptHeader">The sales shipment header.</param>    /// <param name="IsHandled">Set to true to skip default posting.</param>    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnBeforeRunItemJnlPostLine(var ItemJnlLine: Record "Item Journal Line"; ItemLedgEntryNotInvoiced: Record "Item Ledger Entry"; SalesShptLine: Record "Sales Shipment Line"; SalesShptHeader: Record "Sales Shipment Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before updating the sales order line quantities during the undo process.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    /// <param name="SalesLine">The sales order line to be updated.</param>    [IntegrationEvent(false, false)]    local procedure OnUpdateOrderLineOnBeforeUpdateSalesLine(var SalesShipmentLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised after determining whether the related sales invoice was cancelled.    /// </summary>    /// <param name="SalesInvoiceHeader">The sales invoice header being checked.</param>    /// <param name="Result">The result indicating whether the invoice was cancelled.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterIsSalesInvoiceCancelled(var SalesInvoiceHeader: Record "Sales Invoice Header"; var Result: Boolean)    begin    end;    /// <summary>    /// Raised before collecting item ledger entries during shipment line validation.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line being validated.</param>    /// <param name="TempItemLedgEntry">Temporary item ledger entries to collect.</param>    /// <param name="IsHandled">Set to true to skip default collection.</param>    [IntegrationEvent(false, false)]    local procedure OnCheckSalesShptLineOnBeforeCollectItemLedgEntries(SalesShptLine: Record "Sales Shipment Line"; var TempItemLedgEntry: Record "Item Ledger Entry" temporary; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking whether the line has invoiced but not returned quantity.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line being checked.</param>    /// <param name="IsHandled">Set to true to skip default quantity check.</param>    [IntegrationEvent(false, false)]    local procedure OnCheckSalesShptLineOnBeforeHasInvoicedNotReturnedQuantity(SalesShptLine: Record "Sales Shipment Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before modifying the sales line during assemble-to-order synchronization.    /// </summary>    /// <param name="SalesLine">The sales line to be modified.</param>    [IntegrationEvent(false, false)]    local procedure OnSynchronizeATOOnBeforeModify(var SalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised after posting the item journal line during the undo shipment process.    /// </summary>    /// <param name="ItemJournalLine">The posted item journal line.</param>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var SalesShipmentLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised after processing invoiced shipment entries before exiting the posting routine.    /// </summary>    /// <param name="ItemJournalLine">The item journal line being processed.</param>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    [IntegrationEvent(false, false)]    local procedure OnItemJnlPostLineOnAfterGetInvoicedShptEntriesOnBeforeExit(var ItemJournalLine: Record "Item Journal Line"; var SalesShipmentLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised after calculating the remaining base quantity during item journal posting.    /// </summary>    /// <param name="RemQtyBase">The calculated remaining base quantity.</param>    /// <param name="ItemJournalLine">The item journal line being processed.</param>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    /// <param name="ItemLedgerEntryNotInvoiced">The item ledger entry not invoiced.</param>    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterCalcRemQtyBase(var RemQtyBase: Decimal; var ItemJournalLine: Record "Item Journal Line"; var SalesShipmentLine: Record "Sales Shipment Line"; var ItemLedgerEntryNotInvoiced: Record "Item Ledger Entry")    begin    end;    /// <summary>    /// Raised after setting filters to retrieve invoiced shipment entries.    /// </summary>    /// <param name="ItemLedgerEntry">The item ledger entry with applied filters.</param>    /// <param name="SalesShipmentLine">The sales shipment line being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnGetInvoicedShptEntriesOnAfterSetFilters(var ItemLedgerEntry: Record "Item Ledger Entry"; SalesShipmentLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised before processing item shipment entries during the undo process.    /// </summary>    /// <param name="ItemShptEntryNo">The item shipment entry number.</param>    /// <param name="DocLineNo">The document line number.</param>    /// <param name="SalesShipmentLine">The sales shipment line being processed.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnCodeOnBeforeProcessItemShptEntry(var ItemShptEntryNo: Integer; var DocLineNo: Integer; var SalesShipmentLine: Record "Sales Shipment Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised after validating all sales shipment lines before starting the undo process.    /// </summary>    /// <param name="SalesShipmentLine">The validated sales shipment lines.</param>    /// <param name="UndoSalesShptLineParams">The undo parameters being used.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckSalesShipmentLines(var SalesShipmentLine: Record "Sales Shipment Line"; var UndoSalesShptLineParams: Record "Undo Sales Shpt. Line Params")    begin    end;    /// <summary>    /// Raised before deleting related items during the undo shipment process.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line being undone.</param>    /// <param name="UndoSalesShptLineParams">The undo parameters being used.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteRelatedItems(var SalesShipmentLine: Record "Sales Shipment Line"; UndoSalesShptLineParams: Record "Undo Sales Shpt. Line Params")    begin    end;    /// <summary>    /// Raised before finding the item application entry for a drop shipment being unapplied.    /// </summary>    /// <param name="ItemApplicationEntry">The item application entry with applied filters.</param>    /// <param name="ItemLedgerEntry">The item ledger entry for the drop shipment.</param>    [IntegrationEvent(false, false)]    local procedure OnUnApplyDropShipmentOnBeforeFindItemApplicationEntry(var ItemApplicationEntry: Record "Item Application Entry"; ItemLedgerEntry: Record "Item Ledger Entry")    begin    end;}