Codeunit 80 Sales-Post

Base Application, Microsoft.Sales.Posting

src/Layers/W1/BaseApp/Sales/Posting/SalesPost.Codeunit.al14,025 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.Posting;using Microsoft.Assembly.Document;using Microsoft.Assembly.History;using Microsoft.Assembly.Posting;using Microsoft.CRM.Contact;using Microsoft.CRM.Opportunity;using Microsoft.CRM.Outlook;using Microsoft.CRM.Segment;using Microsoft.EServices.EDocument;using Microsoft.Finance.Analysis;using Microsoft.Finance.Currency;using Microsoft.Finance.Deferral;using Microsoft.Finance.Dimension;using Microsoft.Finance.GeneralLedger.Account;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Ledger;using Microsoft.Finance.GeneralLedger.Posting;using Microsoft.Finance.GeneralLedger.Preview;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Finance.ReceivablesPayables;using Microsoft.Finance.VAT.Calculation;using Microsoft.Finance.VAT.Setup;using Microsoft.FixedAssets.Depreciation;using Microsoft.FixedAssets.FixedAsset;using Microsoft.Foundation.AuditCodes;using Microsoft.Foundation.BatchProcessing;using Microsoft.Foundation.ExtendedText;using Microsoft.Foundation.NoSeries;using Microsoft.Foundation.Reporting;using Microsoft.Foundation.UOM;using Microsoft.Integration.D365Sales;using Microsoft.Integration.Graph;using Microsoft.Intercompany;using Microsoft.Intercompany.GLAccount;using Microsoft.Intercompany.Inbox;using Microsoft.Intercompany.Outbox;using Microsoft.Intercompany.Partner;using Microsoft.Inventory.Analysis;using Microsoft.Inventory.Costing;using Microsoft.Inventory.Item;using Microsoft.Inventory.Journal;using Microsoft.Inventory.Ledger;using Microsoft.Inventory.Location;using Microsoft.Inventory.Posting;using Microsoft.Inventory.Setup;using Microsoft.Inventory.Tracking;using Microsoft.Projects.Project.Archive;using Microsoft.Projects.Project.Job;using Microsoft.Projects.Project.Posting;using Microsoft.Projects.Resources.Journal;using Microsoft.Purchases.Comment;using Microsoft.Purchases.Document;using Microsoft.Purchases.History;using Microsoft.Purchases.Posting;using Microsoft.Purchases.Setup;using Microsoft.Purchases.Vendor;using Microsoft.Sales.Comment;using Microsoft.Sales.Customer;using Microsoft.Sales.Document;using Microsoft.Sales.History;using Microsoft.Sales.Receivables;using Microsoft.Sales.Setup;using Microsoft.Utilities;using Microsoft.Warehouse.Activity;using Microsoft.Warehouse.Availability;using Microsoft.Warehouse.Document;using Microsoft.Warehouse.History;using Microsoft.Warehouse.Journal;using Microsoft.Warehouse.Request;using Microsoft.Warehouse.Setup;using System.Automation;using System.Email;using System.Environment.Configuration;using System.Utilities;/// <summary>/// Posts sales documents by creating ledger entries for customers, items, resources, fixed assets, and the general ledger./// </summary>codeunit 80 "Sales-Post"{    Permissions = TableData "Sales Header" = rimd,                  TableData "Sales Line" = rimd,                  TableData "Purchase Header" = rm,                  TableData "Purchase Line" = rm,                  TableData "Sales Shipment Header" = rimd,                  TableData "Sales Shipment Line" = rimd,                  TableData "Sales Invoice Header" = rimd,                  TableData "Sales Invoice Line" = rimd,                  TableData "Sales Cr.Memo Header" = rimd,                  TableData "Sales Cr.Memo Line" = rimd,                  TableData "Purch. Rcpt. Header" = rimd,                  TableData "Purch. Rcpt. Line" = rimd,                  TableData "Drop Shpt. Post. Buffer" = rimd,                  TableData "General Posting Setup" = rimd,                  TableData "Posted Assemble-to-Order Link" = ri,                  TableData "Item Entry Relation" = ri,                  TableData "Value Entry Relation" = rid,                  TableData "Return Receipt Header" = rimd,                  TableData "Return Receipt Line" = rimd,                  TableData "G/L Entry" = r,                  Tabledata Job = r;    TableNo = "Sales Header";    EventSubscriberInstance = Manual;    trigger OnRun()    begin        RunWithCheck(Rec);    end;    var#pragma warning disable AA0470        PostingLinesMsg: Label 'Posting lines              #2######\', Comment = 'Counter';        PostingSalesAndVATMsg: Label 'Posting sales and VAT      #3######\', Comment = 'Counter';        PostingCustomersMsg: Label 'Posting to customers       #4######\', Comment = 'Counter';        PostingBalAccountMsg: Label 'Posting to bal. account    #5######', Comment = 'Counter';        PostingLines2Msg: Label 'Posting lines              #2######', Comment = 'Counter';#pragma warning restore AA0470        InvoiceNoMsg: Label '%1 %2 -> Invoice %3', Comment = '%1 = Document Type, %2 = Document No, %3 = Invoice No.';        CreditMemoNoMsg: Label '%1 %2 -> Credit Memo %3', Comment = '%1 = Document Type, %2 = Document No, %3 = Credit Memo No.';        DropShipmentErr: Label 'You cannot ship sales order line %1. The line is marked as a drop shipment and is not yet associated with a purchase order.', Comment = '%1 = Line No.';        ShipmentSameSignErr: Label 'must have the same sign as the shipment';        ShipmentLinesDeletedErr: Label 'The shipment lines have been deleted.';        InvoiceMoreThanShippedErr: Label 'You cannot invoice more than you have shipped for order %1.', Comment = '%1 = Order No.';        VATAmountTxt: Label 'VAT Amount';        VATRateTxt: Label '%1% VAT', Comment = '%1 = VAT Rate';        BlanketOrderQuantityGreaterThanErr: Label 'in the associated blanket order must not be greater than %1', Comment = '%1 = Quantity';        BlanketOrderQuantityReducedErr: Label 'in the associated blanket order must not be reduced';        ShipInvoiceReceiveErr: Label 'Please enter "Yes" in Ship and/or Invoice and/or Receive.';        WarehouseRequiredErr: Label 'Warehouse handling is required for %1 = %2, %3 = %4, %5 = %6.', Comment = '%1/%2 = Document Type, %3/%4 - Document No.,%5/%6 = Line No.';        ReturnReceiptSameSignErr: Label 'must have the same sign as the return receipt';        ReturnReceiptInvoicedErr: Label 'Line %1 of the return receipt %2, which you are attempting to invoice, has already been invoiced.', Comment = '%1 = Line No., %2 = Document No.';        ShipmentInvoiceErr: Label 'Line %1 of the shipment %2, which you are attempting to invoice, has already been invoiced.', Comment = '%1 = Line No., %2 = Document No.';        QuantityToInvoiceGreaterErr: Label 'The quantity you are attempting to invoice is greater than the quantity in shipment %1.', Comment = '%1 = Document No.';        CannotAssignMoreErr: Label 'You cannot assign more than %1 units in %2 = %3, %4 = %5,%6 = %7.', Comment = '%1 = Quantity, %2/%3 = Document Type, %4/%5 - Document No.,%6/%7 = Line No.';        MustAssignErr: Label 'You must assign all item charges, if you invoice everything.';        Item: Record Item;        SalesSetup: Record "Sales & Receivables Setup";        GLSetup: Record "General Ledger Setup";        [SecurityFiltering(SecurityFilter::Ignored)]        GLEntry: Record "G/L Entry";        TempSalesLineGlobal: Record "Sales Line" temporary;        xSalesLine: Record "Sales Line";        SalesLineACY: Record "Sales Line";        TotalSalesLine: Record "Sales Line";        TotalSalesLineLCY: Record "Sales Line";        SalesShptHeader: Record "Sales Shipment Header";        SalesInvHeader: Record "Sales Invoice Header";        SalesCrMemoHeader: Record "Sales Cr.Memo Header";        ReturnRcptHeader: Record "Return Receipt Header";        PurchRcptHeader: Record "Purch. Rcpt. Header";        ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)";        TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary;        InvoicePostingParameters: Record "Invoice Posting Parameters";        SourceCodeSetup: Record "Source Code Setup";        Currency: Record Currency;        CurrExchRate: Record "Currency Exchange Rate";        WhseRcptHeader: Record "Warehouse Receipt Header";        TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary;        WhseShptHeader: Record "Warehouse Shipment Header";        TempWhseShptHeader: Record "Warehouse Shipment Header" temporary;        PostedWhseRcptHeader: Record "Posted Whse. Receipt Header";        PostedWhseRcptLine: Record "Posted Whse. Receipt Line";        PostedWhseShptHeader: Record "Posted Whse. Shipment Header";        PostedWhseShptLine: Record "Posted Whse. Shipment Line";        Location: Record Location;        TempHandlingSpecification: Record "Tracking Specification" temporary;        TempATOTrackingSpecification: Record "Tracking Specification" temporary;        TempTrackingSpecification: Record "Tracking Specification" temporary;        TempTrackingSpecificationInv: Record "Tracking Specification" temporary;        TempWhseSplitSpecification: Record "Tracking Specification" temporary;        TempValueEntryRelation: Record "Value Entry Relation" temporary;        JobTaskSalesLine: Record "Sales Line";        TempICGenJnlLine: Record "Gen. Journal Line" temporary;        TempPrepmtDeductLCYSalesLine: Record "Sales Line" temporary;        TempSKU: Record "Stockkeeping Unit" temporary;        TempDeferralHeader: Record "Deferral Header" temporary;        TempDeferralLine: Record "Deferral Line" temporary;        ErrorMessageMgt: Codeunit "Error Message Management";        GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line";        ResJnlPostLine: Codeunit "Res. Jnl.-Post Line";        ItemJnlPostLine: Codeunit "Item Jnl.-Post Line";        SalesLineReserve: Codeunit "Sales Line-Reserve";        ApprovalsMgmt: Codeunit "Approvals Mgmt.";        ItemTrackingMgt: Codeunit "Item Tracking Management";        WhseJnlPostLine: Codeunit "Whse. Jnl.-Register Line";        WhsePostRcpt: Codeunit "Whse.-Post Receipt";        WhsePostShpt: Codeunit "Whse.-Post Shipment";        PurchPost: Codeunit "Purch.-Post";        CostCalcMgt: Codeunit "Cost Calculation Management";        JobPostLine: Codeunit "Job Post-Line";        DocumentErrorsMgt: Codeunit "Document Errors Mgt.";        AsmPost: Codeunit "Assembly-Post";        DeferralUtilities: Codeunit "Deferral Utilities";        UOMMgt: Codeunit "Unit of Measure Management";        ApplicationAreaMgmt: Codeunit "Application Area Mgmt.";        InvoicePostingInterface: Interface "Invoice Posting";        IsInterfaceInitalized: Boolean;        Window: Dialog;        GenJnlLineDocNo: Code[20];        GenJnlLineExtDocNo: Code[35];        SrcCode: Code[10];        GenJnlLineDocType: Enum "Gen. Journal Document Type";        ItemLedgShptEntryNo: Integer;        RoundingLineNo: Integer;        RemQtyToBeInvoiced: Decimal;        RemQtyToBeInvoicedBase: Decimal;        RemAmt: Decimal;        RemDiscAmt: Decimal;        TotalChargeAmt: Decimal;        TotalChargeAmtLCY: Decimal;        RoundedPrevTotalChargeAmt: Decimal;        PreciseTotalChargeAmt: Decimal;        LastLineRetrieved: Boolean;        RoundingLineInserted: Boolean;        DropShipOrder: Boolean;        DocumentIsReadyToBeChecked: Boolean;        PostponedValueEntries: List of [Integer];        ItemsToAdjust: List of [Code[20]];        CannotAssignInvoicedErr: Label 'You cannot assign item charges to the %1 %2 = %3,%4 = %5, %6 = %7, because it has been invoiced.', Comment = '%1 = Sales Line, %2/%3 = Document Type, %4/%5 - Document No.,%6/%7 = Line No.';        InvoiceMoreThanReceivedErr: Label 'You cannot invoice more than you have received for return order %1.', Comment = '%1 = Order No.';        ReturnReceiptLinesDeletedErr: Label 'The return receipt lines have been deleted.';        InvoiceGreaterThanReturnReceiptErr: Label 'The quantity you are attempting to invoice is greater than the quantity in return receipt %1.', Comment = '%1 = Receipt No.';        ItemJnlRollRndg: Boolean;        RelatedItemLedgEntriesNotFoundErr: Label 'Related item ledger entries cannot be found.';        ItemTrackingWrongSignErr: Label 'Item Tracking is signed wrongly.';        ItemTrackingMismatchErr: Label 'Item Tracking does not match.';        WhseShip: Boolean;        WhseReceive: Boolean;        InvtPickPutaway: Boolean;        PostingDateNotAllowedErr: Label '%1 is not within your range of allowed posting dates.', Comment = '%1 - Posting Date field caption';        ItemTrackQuantityMismatchErr: Label 'The %1 does not match the quantity defined in item tracking for item %2.', Comment = '%1 = Quantity, %2 = Item No.';        CannotBeGreaterThanErr: Label 'cannot be more than %1.', Comment = '%1 = Amount';        CannotBeSmallerThanErr: Label 'must be at least %1.', Comment = '%1 = Amount';        JobContractLine: Boolean;        GLSetupRead: Boolean;        SalesSetupRead: Boolean;        ItemTrkgAlreadyOverruled: Boolean;        LogErrorMode: Boolean;        PrepAmountToDeductToBigErr: Label 'The total %1 cannot be more than %2.', Comment = '%1 = Prepmt Amt to Deduct, %2 = Max Amount';        PrepAmountToDeductToSmallErr: Label 'The total %1 must be at least %2.', Comment = '%1 = Prepmt Amt to Deduct, %2 = Max Amount';        MustAssignItemChargeErr: Label 'You must assign item charge %1 if you want to invoice it.', Comment = '%1 = Item Charge No.';        CannotInvoiceItemChargeErr: Label 'You can not invoice item charge %1 because there is no item ledger entry to assign it to.', Comment = '%1 = Item Charge No.';        SalesLinesProcessed: Boolean;        AssemblyCheckProgressMsg: Label '#1#################################\\Checking Assembly #2###########', Comment = '%1 = Text, %2 = Progress bar';        AssemblyPostProgressMsg: Label '#1#################################\\Posting Assembly #2###########', Comment = '%1 = Text, %2 = Progress bar';        AssemblyFinalizeProgressMsg: Label '#1#################################\\Finalizing Assembly #2###########', Comment = '%1 = Text, %2 = Progress bar';        ReassignItemChargeErr: Label 'The order line that the item charge was originally assigned to has been fully posted. You must reassign the item charge to the posted receipt or shipment.';#pragma warning disable AA0470        ReservationDisruptedQst: Label 'One or more reservation entries exist for the item with %1 = %2, %3 = %4, %5 = %6 which may be disrupted if you post this negative adjustment. Do you want to continue?', Comment = 'One or more reservation entries exist for the item with No. = 1000, Location Code = SILVER, Variant Code = NEW which may be disrupted if you post this negative adjustment. Do you want to continue?';#pragma warning restore AA0470        NotSupportedDocumentTypeErr: Label 'Document type %1 is not supported.', Comment = '%1 = Document Type';        CalledBy: Integer;        PreviewMode: Boolean;        TotalInvoiceAmountNegativeErr: Label 'The total amount for the invoice must be 0 or greater.';        SendShipmentAlsoQst: Label 'You can take the same actions for the related Sales - Shipment document.\\Do you want to do that now?';        SuppressCommit: Boolean;        PostingPreviewNoTok: Label '***', Locked = true;        PostingPreviewNoFormatTxt: Label '<Integer,6><Filler Character,0>', Comment = 'Previewed document numbers are displayed in the format ***000000', Locked = true;        InvPickExistsErr: Label 'One or more related inventory picks must be registered before you can post the shipment.';        InvPutAwayExistsErr: Label 'One or more related inventory put-aways must be registered before you can post the receipt.';        CheckSalesHeaderMsg: Label 'Check sales document fields.';        CheckSalesLineMsg: Label 'Check sales document line.';        PostDocumentLinesMsg: Label 'Post document lines.';        HideProgressWindow: Boolean;        OrderArchived: Boolean;        SetupBlockedErr: Label 'Setup is blocked in %1 for %2 %3 and %4 %5.', Comment = '%1 - General/VAT Posting Setup, %2 %3 %4 %5 - posting groups.';        SalesReturnRcptHeaderConflictErr: Label 'Cannot post the sales return because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Return Receipt No.';        SalesShptHeaderConflictErr: Label 'Cannot post the sales shipment because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Shipping No.';        SalesInvHeaderConflictErr: Label 'Cannot post the sales invoice because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Posting No.';        SalesCrMemoHeaderConflictErr: Label 'Cannot post the sales credit memo because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Posting No.';        SalesLinePostCategoryTok: Label 'Sales Line Post', Locked = true;        SameIdFoundLbl: Label 'Same line id found.', Locked = true;        EmptyIdFoundLbl: Label 'Empty line id found.', Locked = true;        ItemReservDisruptionLbl: Label 'Confirm Item Reservation Disruption', Locked = true;        ItemChargeZeroAmountErr: Label 'The amount for item charge %1 cannot be 0.', Comment = '%1 = Item Charge No.';        SuppressCommitErr: Label 'Commit is blocked when %1 %2 is used.', Comment = '%1 = Date Order, %2 = Number Series';        DateOrderSeriesUsed: Boolean;    /// <summary>    /// Verifies and posts the sales document.    /// As a result, posted documents will be created, dependent on the type of the document, as well as any relevant posting to inventory and finance.    /// A Quote cannot be posted - it has to be turned into an order or invoice first, which then can be posted.    /// An Order can be shipped and/or invoiced.    /// A Return order can be received and/or invoiced.    /// An Invoice and a Credit memo can be invoiced.    /// Any document, except quote, can be partly shipped/received/invoiced.    /// </summary>    /// <param name="SalesHeader2">The sales header of the document that is being posted.</param>    internal procedure RunWithCheck(var SalesHeader2: Record "Sales Header")    var        SalesHeader: Record "Sales Header";        CustLedgEntry: Record "Cust. Ledger Entry";        TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary;        DisableAggregateTableUpdate: Codeunit "Disable Aggregate Table Update";        UpdateAnalysisView: Codeunit "Update Analysis View";        UpdateItemAnalysisView: Codeunit "Update Item Analysis View";        SequenceNoMgt: Codeunit "Sequence No. Mgt.";        EverythingInvoiced: Boolean;        SavedPreviewMode: Boolean;        SavedSuppressCommit: Boolean;        SavedCalledBy: Integer;        SavedHideProgressWindow: Boolean;        IsHandled: Boolean;    begin        SequenceNoMgt.SetPreviewMode(PreviewMode);        IsHandled := false;        OnBeforePostSalesDoc(SalesHeader2, SuppressCommit, PreviewMode, HideProgressWindow, IsHandled, CalledBy);        if IsHandled then            exit;        GetSalesHeader(SalesHeader2);        if not GuiAllowed() then            LockTimeout(false);        SetupDisableAggregateTableUpdate(SalesHeader2, DisableAggregateTableUpdate);        ValidatePostingAndDocumentDate(SalesHeader2);        SavedPreviewMode := PreviewMode;        SavedSuppressCommit := SuppressCommit;        SavedHideProgressWindow := HideProgressWindow;        SavedCalledBy := CalledBy;        ClearAllVariables();        SuppressCommit := SavedSuppressCommit;        PreviewMode := SavedPreviewMode;        HideProgressWindow := SavedHideProgressWindow;        CalledBy := SavedCalledBy;        GetGLSetup();        GetSalesSetup();        GetInvoicePostingSetup();        GetCurrency(SalesHeader2."Currency Code");        SalesHeader := SalesHeader2;        OnCodeOnBeforeFillTempLines(SalesHeader, CalledBy);        FillTempLines(SalesHeader, TempSalesLineGlobal);        // Check that the invoice amount is zero or greater        OnRunOnBeforeCheckTotalInvoiceAmount(SalesHeader, TempSalesLineGlobal);        if SalesHeader.Invoice then            CheckTotalInvoiceAmount(SalesHeader);        OnRunOnBeforeCheckAndUpdate(SalesHeader);        // Header        CheckAndUpdate(SalesHeader);        ProcessPosting(SalesHeader, SalesHeader2, TempDropShptPostBuffer, CustLedgEntry, EverythingInvoiced);        UpdateLastPostingNos(SalesHeader);        OnRunOnBeforeFinalizePosting(          SalesHeader, SalesShptHeader, SalesInvHeader, SalesCrMemoHeader, ReturnRcptHeader, GenJnlPostLine, SuppressCommit,          GenJnlLineExtDocNo, EverythingInvoiced, GenJnlLineDocNo, SrcCode, PreviewMode);        if not (SalesHeader."Document Type" in [SalesHeader."Document Type"::Invoice, SalesHeader."Document Type"::"Credit Memo"]) then            EnableAggregateTableUpdate(DisableAggregateTableUpdate);        FinalizePosting(SalesHeader, EverythingInvoiced, TempDropShptPostBuffer);        SalesHeader2 := SalesHeader;        OnRunWithCheckOnAfterFinalize(SalesHeader);        // Date-ordered No. Series require that number allocation and the posted document are in the same        // transaction to prevent gaps. At this point FinalizePosting has completed, so both the allocated        // number and the posted document exist in the current transaction — committing is safe.        // Restore SuppressCommit to the caller's original value so that the date-order guard        // no longer blocks the final commit.        if DateOrderSeriesUsed and SuppressCommit then            SuppressCommit := SavedSuppressCommit;        if not (InvtPickPutaway or SuppressCommit or PreviewMode) then begin            Commit();            UpdateAnalysisView.UpdateAll(0, true);            UpdateItemAnalysisView.UpdateAll(0, true);        end;        OnAfterPostSalesDoc(          SalesHeader2, GenJnlPostLine, SalesShptHeader."No.", ReturnRcptHeader."No.",          SalesInvHeader."No.", SalesCrMemoHeader."No.", SuppressCommit, InvtPickPutaway,          CustLedgEntry, WhseShip, WhseReceive, PreviewMode);        OnAfterPostSalesDocDropShipment(PurchRcptHeader."No.", SuppressCommit);    end;    /// <summary>    /// A wrapper function to delegate to either a function that allows commit or a function that ignores commit    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesHeader2">An unmodified copy of the sales header.</param>    /// <param name="TempDropShptPostBuffer">An internal temp table holding drop shipment information.</param>    /// <param name="CustLedgEntry">The customer ledger entry we are creating (='the invoice').</param>    /// <param name="EverythingInvoiced">A flag telling whether it was a partial invoice and something is still left.</param>    local procedure ProcessPosting(var SalesHeader: Record "Sales Header"; var SalesHeader2: Record "Sales Header";                                   var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary;                                   var CustLedgEntry: Record "Cust. Ledger Entry";                                   var EverythingInvoiced: Boolean)    var        IgnoreCommit: Boolean;    begin        IgnoreCommit := true;        OnSetCommitBehavior(IgnoreCommit);        if IgnoreCommit then            ProcessPostingLinesCommitBehaviorIgnore(                SalesHeader, SalesHeader2, TempDropShptPostBuffer, CustLedgEntry, EverythingInvoiced)        else            ProcessPostingLines(                SalesHeader, SalesHeader2, TempDropShptPostBuffer, CustLedgEntry, EverythingInvoiced);    end;    /// <summary>    /// A wrapper function to delegate to the ProcessPostingLines function in order to ignore commits    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesHeader2">An unmodified copy of the sales header.</param>    /// <param name="TempDropShptPostBuffer">An internal temp table holding drop shipment information.</param>    /// <param name="CustLedgEntry">The customer ledger entry we are creating (='the invoice').</param>    /// <param name="EverythingInvoiced">A flag telling whether it was a partial invoice and something is still left.</param>    [CommitBehavior(CommitBehavior::Ignore)]    local procedure ProcessPostingLinesCommitBehaviorIgnore(var SalesHeader: Record "Sales Header"; var SalesHeader2: Record "Sales Header";                                   var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary;                                   var CustLedgEntry: Record "Cust. Ledger Entry";                                   var EverythingInvoiced: Boolean)    begin        ProcessPostingLines(SalesHeader, SalesHeader2, TempDropShptPostBuffer, CustLedgEntry, EverythingInvoiced);    end;    /// <summary>    /// The main function that processes the document lines.    /// Will update inventory, finance, resources, jobs, etc., dependent on what lines are in the document.    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesHeader2">An unmodified copy of the sales header.</param>    /// <param name="TempDropShptPostBuffer">An internal temp table holding drop shipment information.</param>    /// <param name="CustLedgEntry">The customer ledger entry we are creating (='the invoice').</param>    /// <param name="EverythingInvoiced">A flag telling whether it was a partial invoice and something is still left.</param>    local procedure ProcessPostingLines(var SalesHeader: Record "Sales Header"; var SalesHeader2: Record "Sales Header";                                   var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary;                                   var CustLedgEntry: Record "Cust. Ledger Entry";                                   var EverythingInvoiced: Boolean)    var        TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary;        TempVATAmountLine: Record "VAT Amount Line" temporary;        TempVATAmountLineRemainder: Record "VAT Amount Line" temporary;        InventorySetup: Record "Inventory Setup";        ErrorContextElementProcessLines: Codeunit "Error Context Element";        ErrorContextElementPostLine: Codeunit "Error Context Element";        ZeroSalesLineRecID: RecordId;        ICGenJnlLineNo: Integer;        LineCount: Integer;        BiggestLineNo: Integer;        HasATOShippedNotInvoiced: Boolean;        SkipInventoryAdjustment: Boolean;        IsHandled: Boolean;    begin        InvoicePostingInterface.ClearBuffers();        TempDropShptPostBuffer.DeleteAll();        EverythingInvoiced := true;        // Lines        GetZeroSalesLineRecID(SalesHeader, ZeroSalesLineRecID);        ErrorMessageMgt.PushContext(ErrorContextElementProcessLines, ZeroSalesLineRecID, 0, PostDocumentLinesMsg);        OnBeforePostLines(TempSalesLineGlobal, SalesHeader, SuppressCommit, PreviewMode, TempWhseShptHeader, ItemJnlPostLine, TempWhseRcptHeader);        LineCount := 0;        RoundingLineInserted := false;        AdjustFinalInvWith100PctPrepmt(TempSalesLineGlobal);        TempVATAmountLineRemainder.DeleteAll();        IsHandled := false;        OnRunOnBeforeCalcVATAmountLines(TempSalesLineGlobal, SalesHeader, TempVATAmountLine, IsHandled);        if not IsHandled then            TempSalesLineGlobal.CalcVATAmountLines(1, SalesHeader, TempSalesLineGlobal, TempVATAmountLine);        OnBeforePostSalesLines(SalesHeader, TempSalesLineGlobal, TempVATAmountLine, EverythingInvoiced);        Clear(PostponedValueEntries);        BindSubscription(this); // Start collect value entries for GLPosting        SalesLinesProcessed := false;        if not InventorySetup.UseLegacyPosting() then            TempSalesLineGlobal.SetCurrentKey(Type, "Line No.");        if TempSalesLineGlobal.FindSet() then            repeat                ErrorMessageMgt.PushContext(ErrorContextElementPostLine, TempSalesLineGlobal.RecordId, 0, PostDocumentLinesMsg);                ItemJnlRollRndg := false;                LineCount := LineCount + 1;                if GuiAllowed() and not HideProgressWindow then                    Window.Update(2, LineCount);                PostSalesLine(                  SalesHeader, TempSalesLineGlobal, EverythingInvoiced, TempVATAmountLine, TempVATAmountLineRemainder,                  TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced, TempDropShptPostBuffer, ICGenJnlLineNo);                UpdateInvoiceRounding(SalesHeader, BiggestLineNo);                OnRunOnBeforePostSalesLineEndLoop(                    SalesHeader, TempSalesLineGlobal, LastLineRetrieved, SalesInvHeader, SalesCrMemoHeader, SalesHeader2, xSalesLine, SalesShptHeader, ReturnRcptHeader);                ErrorMessageMgt.PopContext(ErrorContextElementPostLine);            until LastLineRetrieved;        TempSalesLineGlobal.SetCurrentKey("Document Type", "Document No.", "Line No.");        UnBindSubscription(this); // Stop collecting value entries for GLPosting        ItemJnlPostLine.PostDeferredValueEntriesToGL(PostponedValueEntries);        OnAfterPostSalesLines(          SalesHeader, SalesShptHeader, SalesInvHeader, SalesCrMemoHeader, ReturnRcptHeader, WhseShip, WhseReceive, SalesLinesProcessed,          SuppressCommit, EverythingInvoiced, TempSalesLineGlobal);        ErrorMessageMgt.PopContext(ErrorContextElementProcessLines);        ErrorMessageMgt.Finish(ZeroSalesLineRecID);        SendICDocument(SalesHeader);        UpdateHandledICInboxTransaction(SalesHeader);        if not SalesHeader.IsCreditDocType() then begin            ReverseAmount(TotalSalesLine);            ReverseAmount(TotalSalesLineLCY);            TotalSalesLineLCY."Unit Cost (LCY)" := -TotalSalesLineLCY."Unit Cost (LCY)";        end;        OnProcessPostingLinesOnBeforePostDropOrderShipment(SalesHeader, TotalSalesLine, TotalSalesLineLCY);        PostDropOrderShipment(SalesHeader, TempDropShptPostBuffer);        if SalesHeader.Invoice then            PostInvoice(SalesHeader, CustLedgEntry);        OnRunOnBeforePostICGenJnl(SalesHeader, SalesInvHeader, SalesCrMemoHeader, GenJnlPostLine, SrcCode, GenJnlLineDocType, GenJnlLineDocNo, ReturnRcptHeader, PreviewMode);        if ICGenJnlLineNo > 0 then            PostICGenJnl();        SkipInventoryAdjustment := false;        OnRunOnBeforeMakeInventoryAdjustment(SalesHeader, SalesInvHeader, GenJnlPostLine, ItemJnlPostLine, PreviewMode, SkipInventoryAdjustment);        if not SkipInventoryAdjustment then            MakeInventoryAdjustment();    end;    /// <summary>    /// Generates a record id for an 'empty' line    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLineRecID">Return value: The record ID of the 'empty' line.</param>    local procedure GetZeroSalesLineRecID(SalesHeader: Record "Sales Header"; var SalesLineRecID: RecordId)    var        ZeroSalesLine: Record "Sales Line";    begin        ZeroSalesLine."Document Type" := SalesHeader."Document Type";        ZeroSalesLine."Document No." := SalesHeader."No.";        ZeroSalesLine."Line No." := 0;        SalesLineRecID := ZeroSalesLine.RecordId;    end;    /// <summary>    /// Copies all the sales lines to a temporary table to speed up later processing    /// </summary>    /// <remarks>    /// If the item charge exists for an item in sales sine, then gen. prod. posting group of item charge is copied to the sales line.    /// </remarks>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="TempSalesLine">Return value: The temp table that holds a copy of all sales lines.</param>    procedure CopyToTempLines(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    var        SalesLine: Record "Sales Line";    begin        SalesLine.SetRange("Document Type", SalesHeader."Document Type");        SalesLine.SetRange("Document No.", SalesHeader."No.");        OnCopyToTempLinesOnAfterSetFilters(SalesLine, SalesHeader);        if SalesLine.FindSet() then            repeat                UpdateChargeItemSalesLineGenProdPostingGroup(SalesLine);                TempSalesLine := SalesLine;                TempSalesLine.Insert();            until SalesLine.Next() = 0;        OnAfterCopyToTempLines(TempSalesLine, SalesHeader);    end;    /// <summary>    /// Copies all the sales lines to a temporary table, if they haven't been copied yet, to speed up later processing    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="TempSalesLine">Return value: The temp table that holds a copy of all sales lines.</param>    procedure FillTempLines(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin        TempSalesLine.Reset();        if TempSalesLine.IsEmpty() then            CopyToTempLines(SalesHeader, TempSalesLine);    end;    local procedure SetupDisableAggregateTableUpdate(var SalesHeader: Record "Sales Header"; var DisableAggregateTableUpdate: Codeunit "Disable Aggregate Table Update")    var        AggregateTableID: Integer;    begin        AggregateTableID := DisableAggregateTableUpdate.GetAggregateTableIDFromSalesHeader(SalesHeader);        if not (AggregateTableID > 0) then            exit;        DisableAggregateTableUpdate.SetAggregateTableIDDisabled(AggregateTableID);        DisableAggregateTableUpdate.SetTableSystemIDDisabled(SalesHeader.SystemId);        BindSubscription(DisableAggregateTableUpdate);    end;    local procedure EnableAggregateTableUpdate(var DisableAggregateTableUpdate: Codeunit "Disable Aggregate Table Update")    begin        if UnbindSubscription(DisableAggregateTableUpdate) then;    end;    local procedure ModifyTempLine(var TempSalesLineLocal: Record "Sales Line" temporary)    var        SalesLine: Record "Sales Line";    begin        TempSalesLineLocal.Modify();        SalesLine.Get(TempSalesLineLocal.RecordId);        OnModifyTempLineOnBeforeTransferFields(SalesLine, TempSalesLineLocal);        SalesLine.TransferFields(TempSalesLineLocal, false);        OnModifyTempLineOnBeforeSalesLineModify(SalesLine);        SalesLine.Modify();        OnModifyTempLineOnAfterSalesLineModify(SalesLine);    end;    /// <summary>    /// Deletes the sales line from the temp table and copies them again to account for any changes done to the document lines as part of the posting process    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="TempSalesLine">Return value: The temp table that holds a fresh copy of all sales lines.</param>    procedure RefreshTempLines(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin        TempSalesLine.Reset();        TempSalesLine.SetRange("Prepayment Line", false);        TempSalesLine.DeleteAll();        TempSalesLine.Reset();        CopyToTempLines(SalesHeader, TempSalesLine);    end;    /// <summary>    /// Removes any filters on the temp sales line and copies the values from the global temp sales line to the local temp sales line    /// </summary>    /// <param name="TempSalesLineLocal">Return value: The local temp table that holds a copy of all sales lines.</param>    procedure ResetTempLines(var TempSalesLineLocal: Record "Sales Line" temporary)    begin        TempSalesLineLocal.Reset();        TempSalesLineLocal.Copy(TempSalesLineGlobal, true);        OnAfterResetTempLines(TempSalesLineLocal);    end;    /// <summary>    /// Checks if a new invoice should be created for the document    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <returns>True if a new invoice should be created, false otherwise.</returns>    local procedure CalcInvoice(SalesHeader: Record "Sales Header") NewInvoice: Boolean    var        TempSalesLine: Record "Sales Line" temporary;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcInvoice(SalesHeader, TempSalesLineGlobal, NewInvoice, IsHandled);        if IsHandled then            exit(NewInvoice);        ResetTempLines(TempSalesLine);        TempSalesLine.SetFilter(Quantity, '<>0');        if SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"] then            TempSalesLine.SetFilter("Qty. to Invoice", '<>0');        OnCalcInvoiceOnAfterTempSalesLineSetFilters(SalesHeader, TempSalesLine);        NewInvoice := not TempSalesLine.IsEmpty();        if NewInvoice then            case SalesHeader."Document Type" of                SalesHeader."Document Type"::Order:                    if not SalesHeader.Ship then begin                        TempSalesLine.SetFilter("Qty. Shipped Not Invoiced", '<>0');                        NewInvoice := not TempSalesLine.IsEmpty();                    end;                SalesHeader."Document Type"::"Return Order":                    if not SalesHeader.Receive then begin                        TempSalesLine.SetFilter("Return Qty. Rcd. Not Invd.", '<>0');                        NewInvoice := not TempSalesLine.IsEmpty();                    end;            end;        OnAfterCalcInvoice(TempSalesLine, NewInvoice, SalesHeader);        exit(NewInvoice);    end;    /// <summary>    /// Calculates the invoice discount for the document and updates the document and lines accordingly    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    local procedure CalcInvDiscount(var SalesHeader: Record "Sales Header")    var        SalesHeaderCopy: Record "Sales Header";        SalesLine: Record "Sales Line";    begin        if not (SalesSetup."Calc. Inv. Discount" and (SalesHeader.Status <> SalesHeader.Status::Open)) then            exit;        SalesHeaderCopy := SalesHeader;        SalesLine.Reset();        SalesLine.SetRange("Document Type", SalesHeader."Document Type");        SalesLine.SetRange("Document No.", SalesHeader."No.");        OnCalcInvDiscountSetFilter(SalesLine, SalesHeader);        SalesLine.FindFirst();        CODEUNIT.Run(CODEUNIT::"Sales-Calc. Discount", SalesLine);        RefreshTempLines(SalesHeader, TempSalesLineGlobal);        SalesHeader.Get(SalesHeader."Document Type", SalesHeader."No.");        RestoreSalesHeader(SalesHeader, SalesHeaderCopy);        if not (PreviewMode or SuppressCommit) then            Commit();    end;    /// <summary>    /// Restores postings flags and posting numbers of the document header to their original values.    /// </summary>    /// <param name="SalesHeader">Return value: The sales header of the document with the restored values.</param>    /// <param name="SalesHeaderCopy">The sales header of the document with the original values.</param>    local procedure RestoreSalesHeader(var SalesHeader: Record "Sales Header"; SalesHeaderCopy: Record "Sales Header")    begin        SalesHeader.Invoice := SalesHeaderCopy.Invoice;        SalesHeader.Receive := SalesHeaderCopy.Receive;        SalesHeader.Ship := SalesHeaderCopy.Ship;        SalesHeader."Posting No." := SalesHeaderCopy."Posting No.";        SalesHeader."Shipping No." := SalesHeaderCopy."Shipping No.";        SalesHeader."Return Receipt No." := SalesHeaderCopy."Return Receipt No.";        OnAfterRestoreSalesHeader(SalesHeader, SalesHeaderCopy);    end;    /// <summary>    /// Checks if document header and lines are valid for posting, updates the document and lines and creates posted documents.    /// Prepayment lines are created for documents that are invoiced.    /// Unposted document is archived    /// </summary>    /// <remarks>    /// Transaction is commited after updating the document header if posting is not in PreviewMode    /// Several related tables are locked for update after this procedure.    /// DocumentIsReadyToBeChecked is set to true, so that PrepareCheckDocument() is not called again in CheckSalesDocument(). Preparation already happened in RunWithCheck() (parent function).    /// </remarks>    /// <param name="SalesHeader">Return value: The sales header of the document that is being posted, returned with updated values.</param>    local procedure CheckAndUpdate(var SalesHeader: Record "Sales Header")    var        DummyNoSeries: Record "No. Series";        ModifyHeader: Boolean;        RefreshTempLinesNeeded: Boolean;    begin        OnBeforeCheckAndUpdate(SalesHeader, ModifyHeader);        DocumentIsReadyToBeChecked := true; // to avoid re-calling it in CheckSalesDocument()        CheckSalesDocument(SalesHeader);        if SalesHeader.Ship then            InitPostATOs(SalesHeader);        if GuiAllowed() and not HideProgressWindow then            InitProgressWindow(SalesHeader);        // Update        if SalesHeader.Invoice then begin            CreatePrepaymentLines(SalesHeader, true);            CreatePrepaymentLineForCreditMemo(SalesHeader);        end;        DateOrderSeriesUsed := false;        ModifyHeader := UpdatePostingNos(SalesHeader);        if DateOrderSeriesUsed then            SuppressCommit := true;        DropShipOrder := UpdateAssosOrderPostingNos(SalesHeader);        OnBeforePostCommitSalesDoc(SalesHeader, GenJnlPostLine, PreviewMode, ModifyHeader, SuppressCommit, TempSalesLineGlobal);        if DateOrderSeriesUsed and (not SuppressCommit) then            Error(SuppressCommitErr, DummyNoSeries.FieldCaption("Date Order"), DummyNoSeries.TableCaption());        if not PreviewMode and ModifyHeader then begin            SalesHeader.Modify();            if not SuppressCommit then                Commit();        end;        RefreshTempLinesNeeded := false;        OnCheckAndUpdateOnBeforeCalcInvDiscount(          SalesHeader, TempWhseRcptHeader, TempWhseShptHeader, WhseReceive, WhseShip, RefreshTempLinesNeeded);        if RefreshTempLinesNeeded then            RefreshTempLines(SalesHeader, TempSalesLineGlobal);        CalcInvDiscount(SalesHeader);        OnCheckAndUpdateOnAfterCalcInvDiscount(SalesHeader, TempWhseShptHeader, PreviewMode, TempSalesLineGlobal, SuppressCommit, WhseReceive, WhseShip);        ReleaseSalesDocument(SalesHeader);        OnCheckAndUpdateOnAfterReleaseSalesDocument(SalesHeader, PreviewMode);        HandleArchiveUnpostedOrder(SalesHeader);        CheckICPartnerBlocked(SalesHeader);        LockTables(SalesHeader);        SourceCodeSetup.Get();        SrcCode := SourceCodeSetup.Sales;        OnCheckAndUpdateOnAfterSetSourceCode(SalesHeader, SourceCodeSetup, SrcCode);        InsertPostedHeaders(SalesHeader);        UpdateIncomingDocument(SalesHeader."Incoming Document Entry No.", SalesHeader."Posting Date", GenJnlLineDocNo);        OnAfterCheckAndUpdate(SalesHeader, SuppressCommit, PreviewMode);    end;    local procedure HandleArchiveUnpostedOrder(var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeHandleArchiveUnpostedOrder(SalesHeader, PreviewMode, IsHandled);        if IsHandled then            exit;        if SalesHeader.Ship or SalesHeader.Receive then            ArchiveUnpostedOrder(SalesHeader);    end;    /// <summary>    /// Main function for checking if document header and lines are valid for posting.    /// Checks for mandatory fields, posting dates, VAT dates, linked documents, posting restrictions, electronic documents, etc.    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    procedure CheckSalesDocument(var SalesHeader: Record "Sales Header")    var        CheckDimensions: Codeunit "Check Dimensions";        ErrorContextElement: Codeunit "Error Context Element";        ForwardLinkMgt: Codeunit "Forward Link Mgt.";        GenJnlCheckLine: Codeunit "Gen. Jnl.-Check Line";        ReportDistributionManagement: Codeunit "Report Distribution Management";        SetupRecID: RecordID;        ModifyHeader: Boolean;        ShouldCheckItemCharge: Boolean;        ShouldCheckDueDate: Boolean;        IsHandled: Boolean;    begin        if not DocumentIsReadyToBeChecked then            PrepareCheckDocument(SalesHeader);        ErrorMessageMgt.PushContext(ErrorContextElement, SalesHeader.RecordId, 0, CheckSalesHeaderMsg);        CheckMandatoryHeaderFields(SalesHeader);        GetGLSetup();        if GLSetup."Journal Templ. Name Mandatory" then            SalesHeader.TestField("Journal Templ. Name", ErrorInfo.Create());        if GenJnlCheckLine.IsDateNotAllowed(SalesHeader."Posting Date", SetupRecID, SalesHeader."Journal Templ. Name") then            ErrorMessageMgt.LogContextFieldError(              SalesHeader.FieldNo(SalesHeader."Posting Date"), StrSubstNo(PostingDateNotAllowedErr, SalesHeader.FieldCaption("Posting Date")),              SetupRecID, ErrorMessageMgt.GetFieldNo(SetupRecID.TableNo, GLSetup.FieldName("Allow Posting From")),              ForwardLinkMgt.GetHelpCodeForAllowedPostingDate());        CheckVATDate(SalesHeader);        OnCheckAndUpdateOnBeforeSetPostingFlags(SalesHeader, TempSalesLineGlobal, ModifyHeader, HideProgressWindow);        if LogErrorMode then            SetLogErrorModePostingFlags(SalesHeader)        else            SetPostingFlags(SalesHeader);        OnCheckAndUpdateOnAfterSetPostingFlags(SalesHeader, TempSalesLineGlobal, ModifyHeader);        if GuiAllowed() and not HideProgressWindow then            InitProgressWindow(SalesHeader);        InvtPickPutaway := SalesHeader."Posting from Whse. Ref." <> 0;        SalesHeader."Posting from Whse. Ref." := 0;        OnCheckAndUpdateOnAfterSetPoszingFromWhseRef(SalesHeader, InvtPickPutaway, SalesHeader."Posting from Whse. Ref.");        IsHandled := false;        OnCheckSalesDocumentOnBeforeCheckSalesDim(SalesHeader, TempSalesLineGlobal, IsHandled);        if not IsHandled then            CheckDimensions.CheckSalesDim(SalesHeader, TempSalesLineGlobal);        OnCheckAndUpdateOnBeforeCheckPostRestrictions(SalesHeader, PreviewMode);        CheckPostRestrictions(SalesHeader);        if SalesHeader.Invoice then            SalesHeader.Invoice := CalcInvoice(SalesHeader);        ShouldCheckItemCharge := SalesHeader.Invoice;        OnCheckSalesDocumentOnAfterCalcShouldCheckItemCharge(SalesHeader, WhseReceive, WhseShip, ShouldCheckItemCharge, ModifyHeader);        if ShouldCheckItemCharge then            CopyAndCheckItemCharge(SalesHeader);        ShouldCheckDueDate := SalesHeader.Invoice and not SalesHeader.IsCreditDocType();        OnCheckSalesDocumentOnBeforeCheckDueDate(SalesHeader, ShouldCheckDueDate);        if ShouldCheckDueDate then            SalesHeader.TestField("Due Date", ErrorInfo.Create());        UpdateShipAndCheckIfInvPickExists(SalesHeader);        UpdateReceiveAndCheckIfInvPutawayExists(SalesHeader);        CheckHeaderPostingType(SalesHeader);        CheckHeaderShippingAdvice(SalesHeader);        CheckAssosOrderLines(SalesHeader);        ReportDistributionManagement.RunDefaultCheckSalesElectronicDocument(SalesHeader);        ErrorMessageMgt.PopContext(ErrorContextElement);        CheckSalesLines(SalesHeader);        OnAfterCheckSalesDoc(SalesHeader, SuppressCommit, WhseShip, WhseReceive, PreviewMode, ErrorMessageMgt);        if not LogErrorMode then            ErrorMessageMgt.Finish(SalesHeader.RecordId);    end;    /// <summary>    /// Checks all sales lines of the document if they are valid for posting.    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    local procedure CheckSalesLines(var SalesHeader: Record "Sales Header")    var        InventorySetup: Record "Inventory Setup";        ErrorContextElement: Codeunit "Error Context Element";        SequenceNoMgt: Codeunit "Sequence No. Mgt.";        NoOfItemLines: Integer;    begin        if TempSalesLineGlobal.FindSet() then            repeat                ErrorMessageMgt.PushContext(ErrorContextElement, TempSalesLineGlobal.RecordId(), 0, CheckSalesLineMsg);                TestSalesLine(SalesHeader, TempSalesLineGlobal);                if (SalesHeader.Ship or SalesHeader.Receive or SalesHeader.Invoice) and (TempSalesLineGlobal.Type = TempSalesLineGlobal.Type::Item) and (TempSalesLineGlobal."Qty. to Ship" <> 0) then                    NoOfItemLines += 1;            until TempSalesLineGlobal.Next() = 0;        ErrorMessageMgt.PopContext(ErrorContextElement);        if not InventorySetup.UseLegacyPosting() and (NoOfItemLines > 0) then begin            if SalesHeader.Ship or SalesHeader.Receive then                SequenceNoMgt.AllocateSeqNoBuffer(Database::"Item Ledger Entry", NoOfItemLines);            SequenceNoMgt.AllocateSeqNoBuffer(Database::"Value Entry", NoOfItemLines);        end;    end;    local procedure CheckTotalInvoiceAmount(SalesHeader: Record "Sales Header")    var        TempVATAmountLine: Record "VAT Amount Line" temporary;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckTotalInvoiceAmount(SalesHeader, IsHandled);        if IsHandled then            exit;        if SalesHeader."Document Type" in [SalesHeader."Document Type"::Invoice, SalesHeader."Document Type"::Order] then begin            TempSalesLineGlobal.CalcVATAmountLines(1, SalesHeader, TempSalesLineGlobal, TempVATAmountLine);            if TempVATAmountLine.GetTotalLineAmount(false, '') < 0 then                if TempVATAmountLine.GetTotalAmountInclVAT() < 0 then                    Error(TotalInvoiceAmountNegativeErr);        end;    end;    /// <summary>    /// Gets all the necessary setup information for the check document process    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    procedure PrepareCheckDocument(var SalesHeader: Record "Sales Header")    begin        OnBeforePrepareCheckDocument(SalesHeader);        GetGLSetup();        GetSalesSetup();        GetInvoicePostingSetup();        GetCurrency(SalesHeader."Currency Code");        FillTempLines(SalesHeader, TempSalesLineGlobal);        LogErrorMode := true;        DocumentIsReadyToBeChecked := true;    end;    local procedure SetLogErrorModePostingFlags(var SalesHeader: Record "Sales Header")    begin        SalesHeader.Ship := SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice];        SalesHeader.Receive := SalesHeader."Document Type" in [SalesHeader."Document Type"::"Return Order", SalesHeader."Document Type"::"Credit Memo"];        SalesHeader.Invoice := true;    end;    /// <summary>    /// Updates sales line quantities and amounts based on the posting type (Ship, Invoice), posts the line and creates a posted document lines.    /// Deferrals and tracking information are posted for the line.    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being posted.</param>    /// <param name="EverythingInvoiced">A flag telling whether it was a partial invoice and something is still left.</param>    /// <param name="TempVATAmountLine">A temp table holding all VAT amounts for the document.</param>    /// <param name="TempVATAmountLineRemainder">A temp table holding Rounding Reminder Amounts for VAT Amounts used to prevent rounding errors when dividing amounts if Qty to post is not equal to full line Qty.</param>    /// <param name="TempItemLedgEntryNotInvoiced">A temp table that will be filled in with all Assemble-to-order item ledger entries that have not been invoiced yet. Used when posting Item tracking for Shipment if Tracking Specification doesn't exist</param>    /// <param name="HasATOShippedNotInvoiced">A flag telling whether there are any Assemble-to-order item ledger entries that have not been invoiced yet. Used when posting Item tracking for Shipment if Tracking Specification doesn't exist</param>    /// <param name="TempDropShptPostBuffer">Return Variable: A temp table that will get an additional entry with Drop Shipment information if it's an Item line.</param>    /// <param name="ICGenJnlLineNo">Return Variable: The line number of the Inter Company General Journal Line for that was created, It's only filled if line type is G/L Account.</param>    local procedure PostSalesLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var EverythingInvoiced: Boolean; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var ICGenJnlLineNo: Integer)    var        SalesInvLine: Record "Sales Invoice Line";        SearchSalesInvLine: Record "Sales Invoice Line";        SalesCrMemoLine: Record "Sales Cr.Memo Line";        SearchSalesCrMemoLine: Record "Sales Cr.Memo Line";        TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary;        CostBaseAmount: Decimal;        ShouldPostLine: Boolean;        ShouldInsertInvoiceLine: Boolean;        IsHandled: Boolean;    begin        if SalesLine.Type = SalesLine.Type::Item then begin            CostBaseAmount := SalesLine."Line Amount";            IsHandled := false;            OnPostSalesLineOnBeforeTestUnitOfMeasureCode(SalesHeader, SalesLine, TempSalesLineGlobal, IsHandled);            // Skip UoM validation for partially shipped/received documents and lines fetch through "Get Shipment Lines"            if not IsHandled then                if (SalesLine."No." <> '') and (SalesLine."Qty. Shipped (Base)" = 0) and (SalesLine."Shipment No." = '') and (SalesLine."Return Qty. Received (Base)" = 0) and (SalesLine."Return Receipt No." = '') then                    SalesLine.TestField("Unit of Measure Code");        end;        if SalesLine."Qty. per Unit of Measure" = 0 then            SalesLine."Qty. per Unit of Measure" := 1;        OnPostSalesLineOnAfterTestSalesLine(SalesLine, SalesHeader, WhseShptHeader, WhseShip, PreviewMode, CostBaseAmount);        TempPostedATOLink.Reset();        TempPostedATOLink.DeleteAll();        if SalesHeader.Ship then            PostATO(SalesHeader, SalesLine, TempPostedATOLink);        OnPostSalesLineOnBeforeUpdateSalesLineBeforePost(SalesLine, SalesHeader, WhseShip, WhseReceive, RoundingLineInserted, SuppressCommit);        UpdateSalesLineBeforePost(SalesHeader, SalesLine);        TestUpdatedSalesLine(SalesLine);        IsHandled := false;        OnPostSalesLineOnAfterTestUpdatedSalesLine(SalesLine, EverythingInvoiced, SalesHeader, IsHandled);        if not IsHandled then            if SalesLine."Qty. to Invoice" + SalesLine."Quantity Invoiced" <> SalesLine.Quantity then                EverythingInvoiced := false;        IsHandled := false;        OnPostSalesLineOnAfterSetEverythingInvoiced(SalesLine, EverythingInvoiced, IsHandled, SalesHeader);        if not IsHandled then            if SalesLine.Quantity <> 0 then                DivideAmount(SalesHeader, SalesLine, 1, SalesLine."Qty. to Invoice", TempVATAmountLine, TempVATAmountLineRemainder);        CheckItemReservDisruption(SalesLine);        RoundAmount(SalesHeader, SalesLine, SalesLine."Qty. to Invoice");        OnPostSalesLineOnAfterRoundAmount(SalesHeader, SalesLine, SalesInvHeader, SalesCrMemoHeader, GenJnlLineDocNo);        if not SalesLine.IsCreditDocType() then begin            ReverseAmount(SalesLine);            ReverseAmount(SalesLineACY);        end;        RemQtyToBeInvoiced := SalesLine."Qty. to Invoice";        RemQtyToBeInvoicedBase := SalesLine."Qty. to Invoice (Base)";        OnPostSalesLineOnBeforePostItemTrackingLine(            SalesHeader, SalesLine, WhseShip, WhseReceive, InvtPickPutaway, SalesInvHeader, SalesCrMemoHeader,            ItemLedgShptEntryNo, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, GenJnlLineDocNo, SrcCode, ItemJnlPostLine);        PostItemTrackingLine(SalesHeader, SalesLine, TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced);        OnPostSalesLineOnAfterPostItemTrackingLine(SalesHeader, SalesLine, WhseShip, WhseReceive, InvtPickPutaway, TempDropShptPostBuffer, TempPostedATOLink);        case SalesLine.Type of            SalesLine.Type::"G/L Account":                PostGLAccICLine(SalesHeader, SalesLine, ICGenJnlLineNo);            SalesLine.Type::Item:                PostItemLine(SalesHeader, SalesLine, TempDropShptPostBuffer, TempPostedATOLink);            SalesLine.Type::Resource:                PostResJnlLine(SalesHeader, SalesLine, JobTaskSalesLine);            SalesLine.Type::"Charge (Item)":                PostItemChargeLine(SalesHeader, SalesLine);        end;        ShouldPostLine := (SalesLine.Type <> SalesLine.Type::" ") and (SalesLine."Qty. to Invoice" <> 0);        OnPostSalesLineOnBeforePostSalesLine(            SalesHeader, SalesLine, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlLineDocType, SrcCode, GenJnlPostLine, ShouldPostLine, SalesLineACY);        if ShouldPostLine then begin            AdjustPrepmtAmountLCY(SalesHeader, SalesLine);            OnPostSalesLineOnAfterAdjustPrepmtAmountLCY(SalesLine, xSalesLine, TempTrackingSpecification, SalesHeader);            InvoicePostingInterface.PrepareLine(SalesHeader, SalesLine, SalesLineACY);        end;        IsHandled := false;        OnPostSalesLineOnBeforeTestJobNo(SalesLine, IsHandled);        if not IsHandled then            if not (SalesLine."Document Type" in [SalesLine."Document Type"::Invoice, SalesLine."Document Type"::"Credit Memo"]) then                SalesLine.TestField("Job No.", '');        IsHandled := false;        OnPostSalesLineOnBeforeInsertShipmentLine(          SalesHeader, SalesLine, IsHandled, SalesLineACY, GenJnlLineDocType.AsInteger(), GenJnlLineDocNo, GenJnlLineExtDocNo);        if not IsHandled then            if (SalesShptHeader."No." <> '') and (SalesLine."Shipment No." = '') and               not RoundingLineInserted and not SalesLine."Prepayment Line"            then                InsertShipmentLine(SalesHeader, SalesShptHeader, SalesLine, CostBaseAmount);        IsHandled := false;        OnPostSalesLineOnBeforeInsertReturnReceiptLine(SalesHeader, SalesLine, IsHandled);        if not IsHandled then            if (ReturnRcptHeader."No." <> '') and (SalesLine."Return Receipt No." = '') and not RoundingLineInserted then                InsertReturnReceiptLine(ReturnRcptHeader, SalesLine, CostBaseAmount, SalesHeader);        OnPostSalesLineOnAfterInsertReturnReceiptLine(SalesHeader, SalesLine, xSalesLine, ReturnRcptHeader, RoundingLineInserted, TempTrackingSpecification, ItemLedgShptEntryNo, SalesShptHeader);        IsHandled := false;        if SalesHeader.Invoice then begin            ShouldInsertInvoiceLine := SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice];            OnPostSalesLineOnBeforeInsertInvoiceLine(SalesHeader, SalesLine, IsHandled, xSalesLine, SalesInvHeader, ShouldInsertInvoiceLine);            if ShouldInsertInvoiceLine and not IsHandled then begin                if not IsHandled then begin                    SalesInvLine.InitFromSalesLine(SalesInvHeader, xSalesLine);                    OnPostSalesLineOnBeforeCollectValueEntryRelation(SalesHeader, SalesLine, SalesInvHeader, SalesInvLine);                    ItemJnlPostLine.CollectValueEntryRelation(TempValueEntryRelation, SalesInvLine.RowID1());                    OnPostSalesLineOnAfterCollectValueEntryRelation(SalesHeader, SalesLine, SalesInvHeader, SalesInvLine);                    SetInvoiceOrderNo(SalesLine, SalesInvLine);                    IsHandled := false;                    OnBeforeSalesInvLineInsert(                        SalesInvLine, SalesInvHeader, xSalesLine, SuppressCommit, IsHandled, SalesLine, SalesShptHeader, SalesHeader, ReturnRcptHeader);                    if IsHandled then                        exit;                    if not IsNullGuid(xSalesLine.SystemId) then begin                        SearchSalesInvLine.SetRange(SystemId, xSalesLine.SystemId);                        if SearchSalesInvLine.IsEmpty() then begin                            SalesInvLine.SystemId := xSalesLine.SystemId;                            SalesInvLine.Insert(true, true);                        end else begin                            Session.LogMessage('0000DD6', SameIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', SalesLinePostCategoryTok);                            SalesInvLine.Insert(true);                        end;                    end else begin                        SalesInvLine.Insert(true);                        Session.LogMessage('0000DDC', EmptyIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', SalesLinePostCategoryTok);                    end;                    OnAfterSalesInvLineInsert(                      SalesInvLine, SalesInvHeader, xSalesLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit,                      SalesHeader, TempItemChargeAssgntSales, TempWhseShptHeader, TempWhseRcptHeader, PreviewMode);                    InvoicePostingInterface.CreatePostedDeferralSchedule(                        xSalesLine, SalesInvLine.GetDocumentType(),                        SalesInvHeader."No.", SalesInvLine."Line No.", SalesInvHeader."Posting Date");                    OnPostSalesLineOnAfterCreatePostedDeferralSchedule(SalesInvLine, SalesInvHeader);                end;            end else begin                OnPostSalesLineOnBeforeInsertCrMemoLine(SalesHeader, SalesLine, IsHandled, xSalesLine, SalesCrMemoHeader);                if not IsHandled then begin                    SalesCrMemoLine.InitFromSalesLine(SalesCrMemoHeader, xSalesLine);                    OnPostSalesLineOnBeforeCollectValueEntryRelationForCrMemo(SalesHeader, SalesLine, SalesInvHeader, SalesInvLine);                    ItemJnlPostLine.CollectValueEntryRelation(TempValueEntryRelation, SalesCrMemoLine.RowID1());                    SetCreditMemoOrderNo(SalesLine, SalesCrMemoLine);                    IsHandled := false;                    OnBeforeSalesCrMemoLineInsert(                        SalesCrMemoLine, SalesCrMemoHeader, xSalesLine, SuppressCommit, IsHandled, SalesHeader, SalesShptHeader, ReturnRcptHeader, SalesLine);                    if IsHandled then                        exit;                    if not IsNullGuid(xSalesLine.SystemId) then begin                        SearchSalesCrMemoLine.SetRange(SystemId, xSalesLine.SystemId);                        if SearchSalesCrMemoLine.IsEmpty() then begin                            SalesCrMemoLine.SystemId := xSalesLine.SystemId;                            SalesCrMemoLine.Insert(true, true);                        end else begin                            Session.LogMessage('0000DD7', SameIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', SalesLinePostCategoryTok);                            SalesCrMemoLine.Insert(true);                        end;                    end else begin                        SalesCrMemoLine.Insert(true);                        Session.LogMessage('0000DDD', SameIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', SalesLinePostCategoryTok);                    end;                    OnAfterSalesCrMemoLineInsert(                      SalesCrMemoLine, SalesCrMemoHeader, SalesHeader, xSalesLine, TempItemChargeAssgntSales, SuppressCommit, WhseShip, WhseReceive, TempWhseShptHeader, TempWhseRcptHeader);                    InvoicePostingInterface.CreatePostedDeferralSchedule(                        xSalesLine, SalesCrMemoLine.GetDocumentType(),                        SalesCrMemoHeader."No.", SalesCrMemoLine."Line No.", SalesCrMemoHeader."Posting Date");                end;            end;        end;        OnAfterPostSalesLine(SalesHeader, SalesLine, SuppressCommit, SalesInvLine, SalesCrMemoLine, xSalesLine);    end;    local procedure SetInvoiceOrderNo(SalesLine: Record "Sales Line"; var SalesInvLine: Record "Sales Invoice Line")    var        SalesShptLine: Record "Sales Shipment Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetInvoiceOrderNo(SalesLine, SalesInvLine, IsHandled);        if IsHandled then            exit;        if SalesLine."Document Type" = SalesLine."Document Type"::Order then begin            SalesInvLine."Order No." := SalesLine."Document No.";            SalesInvLine."Order Line No." := SalesLine."Line No.";        end else            if SalesShptLine.Get(SalesLine."Shipment No.", SalesLine."Shipment Line No.") then begin                SalesInvLine."Order No." := SalesShptLine."Order No.";                SalesInvLine."Order Line No." := SalesShptLine."Order Line No.";            end;    end;    local procedure SetCreditMemoOrderNo(SalesLine: Record "Sales Line"; var SalesCrMemoLine: Record "Sales Cr.Memo Line")    var        ReturnReceiptLine: Record "Return Receipt Line";    begin        if SalesLine."Document Type" = SalesLine."Document Type"::"Return Order" then begin            SalesCrMemoLine."Order No." := SalesLine."Document No.";            SalesCrMemoLine."Order Line No." := SalesLine."Line No.";        end else            if ReturnReceiptLine.Get(SalesLine."Return Receipt No.", SalesLine."Return Receipt Line No.") then begin                SalesCrMemoLine."Order No." := ReturnReceiptLine."Return Order No.";                SalesCrMemoLine."Order Line No." := ReturnReceiptLine."Return Order Line No.";            end;    end;    local procedure UpdateInvoiceRounding(var SalesHeader: Record "Sales Header"; var BiggestLineNo: Integer)    begin        if RoundingLineInserted then            LastLineRetrieved := true        else begin            BiggestLineNo := MAX(BiggestLineNo, TempSalesLineGlobal."Line No.");            LastLineRetrieved := TempSalesLineGlobal.Next() = 0;            if LastLineRetrieved and SalesSetup."Invoice Rounding" then                InvoiceRounding(SalesHeader, TempSalesLineGlobal, false, BiggestLineNo);        end;        OnAfterUpdateInvoiceRounding(            SalesHeader, TotalSalesLine, TempSalesLineGlobal, Currency, BiggestLineNo, LastLineRetrieved, RoundingLineInserted, RoundingLineNo, false);    end;    /// <summary>    /// Posts sales and VAT to G/L entries from posting buffer and posts customer entry    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="CustLedgEntry">Return value: The customer ledger entry that was created.</param>    local procedure PostInvoice(var SalesHeader: Record "Sales Header"; var CustLedgEntry: Record "Cust. Ledger Entry")    var        TotalAmount: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostInvoice(SalesHeader, CustLedgEntry, SuppressCommit, PreviewMode, GenJnlPostLine, IsHandled, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlLineDocType, SrcCode);        if IsHandled then            exit;        // Post sales and VAT to G/L entries from posting buffer        GetInvoicePostingParameters();        InvoicePostingInterface.SetParameters(InvoicePostingParameters);        InvoicePostingInterface.SetTotalLines(TotalSalesLine, TotalSalesLineLCY);        InvoicePostingInterface.PostLines(SalesHeader, GenJnlPostLine, Window, TotalAmount);        OnPostInvoiceOnAfterPostLines(SalesHeader, SrcCode, GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlPostLine);        // Post customer entry        if GuiAllowed() and not HideProgressWindow then            Window.Update(4, 1);        InvoicePostingInterface.SetParameters(InvoicePostingParameters);        InvoicePostingInterface.SetTotalLines(TotalSalesLine, TotalSalesLineLCY);        InvoicePostingInterface.PostLedgerEntry(SalesHeader, GenJnlPostLine);        UpdateSalesHeader(CustLedgEntry, SalesHeader);        // Balancing account        if SalesHeader."Bal. Account No." <> '' then begin            IsHandled := false;            OnPostInvoiceOnBeforeBalAccountNoWindowUpdate(HideProgressWindow, IsHandled, SalesHeader);            if not IsHandled then                if GuiAllowed() and not HideProgressWindow then                    Window.Update(5, 1);            IsHandled := false;            OnPostInvoiceOnBeforePostBalancingEntry(SalesHeader, IsHandled, TotalSalesLine, TotalSalesLineLCY, PreviewMode, SuppressCommit, InvoicePostingParameters, GenJnlPostLine, SalesInvHeader, SalesCrMemoHeader);            if not IsHandled then                InvoicePostingInterface.PostBalancingEntry(SalesHeader, GenJnlPostLine);        end;        OnAfterPostGLAndCustomer(            SalesHeader, GenJnlPostLine, TotalSalesLine, TotalSalesLineLCY, SuppressCommit,            WhseShptHeader, WhseShip, TempWhseShptHeader, SalesInvHeader, SalesCrMemoHeader, CustLedgEntry,            SrcCode, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlLineDocType, PreviewMode, DropShipOrder);    end;    /// <summary>    /// Creates a General Journal Line for Inter Company posting    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being posted.</param>    /// <param name="ICGenJnlLineNo">Return value: The line number of the Inter Company General Journal Line for that was created.</param>    local procedure PostGLAccICLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var ICGenJnlLineNo: Integer)    begin        if (SalesLine."No." <> '') and not SalesLine."System-Created Entry" then begin            CheckGLAccountDirectPosting(SalesLine);            if (SalesLine."IC Partner Code" <> '') and SalesHeader.Invoice then                InsertICGenJnlLine(SalesHeader, xSalesLine, ICGenJnlLineNo);        end;    end;    local procedure CheckGLAccountDirectPosting(SalesLine: Record "Sales Line")    var        GLAcc: Record "G/L Account";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckGLAccountDirectPosting(SalesLine, IsHandled);        if IsHandled then            exit;        GLAcc.Get(SalesLine."No.");        GLAcc.TestField("Direct Posting", true);    end;    /// <summary>    /// Creates and posts (Invoice and Ship) Item Journal Lines for Sales lines of type Item    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being posted. A line with Type "Item" is expected.</param>    /// <param name="TempDropShptPostBuffer">Return Variable: A temp table Set that will get an additional entry with Drop Shipment information.</param>    /// <param name="TempPostedATOLink">A temp table Set containing Posted Assemble-to-Order Links. If a link exists, it posts an item journal line with assembled quantity</param>    procedure PostItemLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary)    var        DummyTrackingSpecification: Record "Tracking Specification";        SalesLineToShip: Record "Sales Line";        QtyToInvoice: Decimal;        QtyToInvoiceBase: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemLine(SalesHeader, SalesLine, IsHandled, TempSalesLineGlobal, TempDropShptPostBuffer, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, ItemJnlPostLine);        if IsHandled then            exit;        ItemLedgShptEntryNo := 0;        QtyToInvoice := RemQtyToBeInvoiced;        QtyToInvoiceBase := RemQtyToBeInvoicedBase;        ProcessAssocItemJnlLine(SalesHeader, SalesLine, TempDropShptPostBuffer);        Clear(TempPostedATOLink);        TempPostedATOLink.SetRange("Order No.", SalesLine."Document No.");        TempPostedATOLink.SetRange("Order Line No.", SalesLine."Line No.");        if TempPostedATOLink.FindFirst() then            PostATOAssocItemJnlLine(SalesHeader, SalesLine, TempPostedATOLink, QtyToInvoice, QtyToInvoiceBase);        OnPostItemLineOnBeforePostItemInvoiceLine(SalesHeader, SalesLine, TempDropShptPostBuffer, TempPostedATOLink, QtyToInvoice, QtyToInvoiceBase);        if QtyToInvoice <> 0 then            ItemLedgShptEntryNo :=              PostItemJnlLine(                SalesHeader, SalesLine,                QtyToInvoice, QtyToInvoiceBase,                QtyToInvoice, QtyToInvoiceBase,                0, '', DummyTrackingSpecification, false);        IsHandled := false;        OnPostItemLineOnBeforeMakeSalesLineToShip(            SalesHeader, SalesLine, TempPostedATOLink, ItemLedgShptEntryNo, IsHandled, GenJnlLineDocNo, GenJnlLineExtDocNo, ReturnRcptHeader,            TempHandlingSpecification, TempTrackingSpecificationInv, TempTrackingSpecification);        if not IsHandled then begin            // Invoice discount amount is also included in expected sales amount posted for shipment or return receipt.            MakeSalesLineToShip(SalesLineToShip, SalesLine);            OnPostItemLineOnAfterMakeSalesLineToShip(SalesHeader, SalesLine, TempDropShptPostBuffer, TempPostedATOLink, QtyToInvoice, QtyToInvoiceBase);            if SalesLineToShip.IsCreditDocType() then begin                if Abs(SalesLineToShip."Return Qty. to Receive") > Abs(QtyToInvoice) then                    ItemLedgShptEntryNo :=                        PostItemJnlLine(                            SalesHeader, SalesLineToShip,                            SalesLineToShip."Return Qty. to Receive" - QtyToInvoice,                            SalesLineToShip."Return Qty. to Receive (Base)" - QtyToInvoiceBase,                            0, 0, 0, '', DummyTrackingSpecification, false);            end else begin                IsHandled := false;                OnPostItemLineOnBeforePostItemJnlLineForInvoiceDoc(SalesHeader, SalesLineToShip, SalesHeader.Ship, ItemLedgShptEntryNo, GenJnlLineDocNo, GenJnlLineExtDocNo, SalesShptHeader, TempHandlingSpecification, TempTrackingSpecificationInv, TempTrackingSpecification, IsHandled, QtyToInvoice, TempPostedATOLink);                if not IsHandled then                    if Abs(SalesLineToShip."Qty. to Ship") > Abs(QtyToInvoice) + Abs(TempPostedATOLink."Assembled Quantity") then                        ItemLedgShptEntryNo :=                            PostItemJnlLine(                                SalesHeader, SalesLineToShip,                                SalesLineToShip."Qty. to Ship" - TempPostedATOLink."Assembled Quantity" - QtyToInvoice,                                SalesLineToShip."Qty. to Ship (Base)" - TempPostedATOLink."Assembled Quantity (Base)" - QtyToInvoiceBase,                                0, 0, 0, '', DummyTrackingSpecification, false);            end;        end;        OnAfterPostItemLine(SalesHeader, SalesLine, QtyToInvoice, QtyToInvoiceBase, SuppressCommit, ItemJnlPostLine);    end;    /// <summary>    /// Processes associated item journal lines for drop shipment orders.    /// </summary>    /// <param name="SalesHeader">Specifies the sales header of the document being posted.</param>    /// <param name="SalesLine">Specifies the sales line being processed.</param>    /// <param name="TempDropShptPostBuffer">Returns the drop shipment posting buffer with the associated item entry.</param>    procedure ProcessAssocItemJnlLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeProcessAssocItemJnlLine(SalesLine, IsHandled, SalesHeader, TempDropShptPostBuffer);        if IsHandled then            exit;        if (SalesLine."Qty. to Ship" <> 0) and (SalesLine."Purch. Order Line No." <> 0) then begin            TempDropShptPostBuffer."Order No." := SalesLine."Purchase Order No.";            TempDropShptPostBuffer."Order Line No." := SalesLine."Purch. Order Line No.";            TempDropShptPostBuffer.Quantity := -SalesLine."Qty. to Ship";            TempDropShptPostBuffer."Quantity (Base)" := -SalesLine."Qty. to Ship (Base)";            OnProcessAssocItemJnlLineOnBeforePostAssocItemJnlLine(TempDropShptPostBuffer, SalesLine);            TempDropShptPostBuffer."Item Shpt. Entry No." :=                PostAssocItemJnlLine(SalesHeader, SalesLine, TempDropShptPostBuffer.Quantity, TempDropShptPostBuffer."Quantity (Base)");            OnProcessAssocItemJnlLineOnBeforeTempDropShptPostBufferInsert(TempDropShptPostBuffer, SalesLine);            TempDropShptPostBuffer.Insert();            SalesLine."Appl.-to Item Entry" := TempDropShptPostBuffer."Item Shpt. Entry No.";        end;    end;    local procedure PostItemChargeLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")    var        SalesLineBackup: Record "Sales Line";        IsHandled: Boolean;    begin        if not (SalesHeader.Invoice and (SalesLine."Qty. to Invoice" <> 0)) then            exit;        IsHandled := false;        OnBeforePostItemChargeLine(SalesHeader, SalesLine, IsHandled);        if IsHandled then            exit;        ItemJnlRollRndg := true;        SalesLineBackup.Copy(SalesLine);        if FindTempItemChargeAssgntSales(SalesLineBackup."Line No.") then            repeat                OnPostItemChargeLineOnBeforePostItemCharge(TempItemChargeAssgntSales, SalesHeader, SalesLineBackup);                case TempItemChargeAssgntSales."Applies-to Doc. Type" of                    TempItemChargeAssgntSales."Applies-to Doc. Type"::Shipment:                        begin                            PostItemChargePerShpt(SalesHeader, SalesLineBackup);                            TempItemChargeAssgntSales.Mark(true);                        end;                    TempItemChargeAssgntSales."Applies-to Doc. Type"::"Return Receipt":                        begin                            PostItemChargePerRetRcpt(SalesHeader, SalesLineBackup);                            TempItemChargeAssgntSales.Mark(true);                        end;                    TempItemChargeAssgntSales."Applies-to Doc. Type"::Order,                    TempItemChargeAssgntSales."Applies-to Doc. Type"::Invoice,                    TempItemChargeAssgntSales."Applies-to Doc. Type"::"Return Order",                    TempItemChargeAssgntSales."Applies-to Doc. Type"::"Credit Memo":                        CheckItemCharge(TempItemChargeAssgntSales);                end;                OnPostItemChargeLineOnAfterTempItemChargeAssgntSalesLoop(TempItemChargeAssgntSales, SalesHeader, SalesLineBackup, SalesLine);            until TempItemChargeAssgntSales.Next() = 0;        OnAfterPostItemChargeLine(SalesLine, SalesLineACY);    end;    /// <summary>    /// Finds Tracking Specification for the sales line, Posts Item Tracking and saves the Tracking Specification in a temp table    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being posted.</param>    /// <param name="TempItemLedgEntryNotInvoiced">A temp table that will be filled in with all Assemble-to-order item ledger entries that have not been invoiced yet. Used when posting Item tracking for Shipment if Tracking Specification doesn't exist</param>    /// <param name="HasATOShippedNotInvoiced">A flag telling whether there are any Assemble-to-order item ledger entries that have not been invoiced yet. Used when posting Item tracking for Shipment if Tracking Specification doesn't exist</param>    local procedure PostItemTrackingLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean)    var        TempTrackingSpecification: Record "Tracking Specification" temporary;        TrackingSpecificationExists: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemTrackingLine(SalesHeader, SalesLine, TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced, IsHandled, ItemLedgShptEntryNo, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, SalesInvHeader, SalesCrMemoHeader);        if IsHandled then            exit;        if SalesLine."Prepayment Line" then            exit;        if SalesHeader.Invoice then            if SalesLine."Qty. to Invoice" = 0 then                TrackingSpecificationExists := false            else                TrackingSpecificationExists :=                  SalesLineReserve.RetrieveInvoiceSpecification(SalesLine, TempTrackingSpecification);        OnPostItemTrackingLineOnAfterRetrieveInvoiceSpecification(SalesLine, TempTrackingSpecification, TrackingSpecificationExists);        PostItemTracking(          SalesHeader, SalesLine, TrackingSpecificationExists, TempTrackingSpecification,          TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced);        if TrackingSpecificationExists then            SaveInvoiceSpecification(TempTrackingSpecification);    end;    /// <summary>    /// Creates and posts Item Journal Line for a sales line    /// Creates Tracking Specification entries for the Journal Line    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being posted.</param>    /// <param name="QtyToBeShipped">The quantity of the Item to be shipped.</param>    /// <param name="QtyToBeShippedBase">The base quantity of the Item to be shipped.</param>    /// <param name="QtyToBeInvoiced">The quantity of the Item to be invoiced.</param>    /// <param name="QtyToBeInvoicedBase">The base quantity of the Item to be invoiced.</param>    /// <param name="ItemLedgShptEntryNo">Item Shipment Entry No. to be assigned to the Item Journal Line.</param>    /// <param name="ItemChargeNo">Item Charge No. to be assigned to the Item Journal Line.</param>    /// <param name="TrackingSpecification">Tracking Specification for the sales line. This parameter is exposed through events, but isn't directly used in the procedure</param>    /// <param name="IsATO">A flag indicating whether the Item is Assemble-to-order.</param>    /// <returns>The Item Shipment Entry No. assigned to the Item Journal Line.</returns>    procedure PostItemJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; ItemLedgShptEntryNo: Integer; ItemChargeNo: Code[20]; TrackingSpecification: Record "Tracking Specification"; IsATO: Boolean) Result: Integer    var        ItemJnlLine: Record "Item Journal Line";        TempWhseJnlLine: Record "Warehouse Journal Line" temporary;        TempWhseTrackingSpecification: Record "Tracking Specification" temporary;        OriginalItemJnlLine: Record "Item Journal Line";        ItemShptEntryNo: Integer;        PostWhseJnlLine: Boolean;        IsHandled: Boolean;        ShouldPostItemJnlLine: Boolean;        ShouldPostItemJnlLineItemCharges: Boolean;    begin        IsHandled := false;        OnBeforePostItemJnlLine(          SalesHeader, SalesLine, QtyToBeShipped, QtyToBeShippedBase, QtyToBeInvoiced, QtyToBeInvoicedBase,          ItemLedgShptEntryNo, ItemChargeNo, TrackingSpecification, IsATO, SuppressCommit, IsHandled, Result, TempTrackingSpecification, TempHandlingSpecification, TempValueEntryRelation, ItemJnlPostLine);        if IsHandled then            exit(Result);        PostItemJnlLinePrepareJournalLine(            ItemJnlLine, SalesHeader, SalesLine, QtyToBeShipped, QtyToBeShippedBase, QtyToBeInvoiced, QtyToBeInvoicedBase,            ItemLedgShptEntryNo, ItemChargeNo, TrackingSpecification, IsATO);        ShouldPostItemJnlLine := not JobContractLine;        OnPostItemJnlLineOnBeforeIsJobContactLineCheck(ItemJnlLine, SalesHeader, SalesLine, ShouldPostItemJnlLine, ItemJnlPostLine, QtyToBeShipped);        if ShouldPostItemJnlLine then begin            PostItemJnlLineBeforePost(ItemJnlLine, SalesLine, TempWhseJnlLine, PostWhseJnlLine, QtyToBeShippedBase, TrackingSpecification);            OriginalItemJnlLine := ItemJnlLine;            if not IsItemJnlPostLineHandled(ItemJnlLine, SalesLine, SalesHeader) then                RunItemJnlPostLine(ItemJnlLine);            OnPostItemJnlLineOnAfterItemJnlPostLineRunWithCheck(ItemJnlPostLine, SalesLine);            if IsATO then                PostItemJnlLineTracking(                  SalesLine, TempWhseTrackingSpecification, PostWhseJnlLine, QtyToBeInvoiced, TempATOTrackingSpecification)            else                PostItemJnlLineTracking(SalesLine, TempWhseTrackingSpecification, PostWhseJnlLine, QtyToBeInvoiced, TempHandlingSpecification);            IsHandled := false;            OnPostItemJnlLineOnBeforePostItemJnlLineWhseLine(              ItemJnlLine, TempWhseJnlLine, TempWhseTrackingSpecification, TempTrackingSpecification, IsHandled, SalesLine);            if not IsHandled then                PostItemJnlLineWhseLine(TempWhseJnlLine, TempWhseTrackingSpecification);            OnAfterPostItemJnlLineWhseLine(SalesLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit);            ShouldPostItemJnlLineItemCharges := (SalesLine.Type = SalesLine.Type::Item) and SalesHeader.Invoice;            OnPostItemJnlLineOnAfterCalcShouldPostItemJnlLineItemCharges(SalesLine, SalesHeader, ShouldPostItemJnlLineItemCharges);            if ShouldPostItemJnlLineItemCharges then                PostItemJnlLineItemCharges(SalesHeader, SalesLine, OriginalItemJnlLine, ItemJnlLine."Item Shpt. Entry No.");        end;        ItemShptEntryNo := ItemJnlLine."Item Shpt. Entry No.";        OnAfterPostItemJnlLine(ItemJnlLine, SalesLine, SalesHeader, ItemJnlPostLine, WhseJnlPostLine, OriginalItemJnlLine, ItemShptEntryNo, IsATO, TempHandlingSpecification, TempATOTrackingSpecification, TempWhseJnlLine, ShouldPostItemJnlLine, WhseShip, WhseRcptHeader, WhseShptHeader);        exit(ItemShptEntryNo);    end;    /// <summary>    /// Prepares Item Journal Line for posting with information from sales header, sales line and parameters    /// </summary>    /// <param name="ItemJnlLine">Return value: The Item Journal Line that was prepared.</param>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being posted.</param>    /// <param name="QtyToBeShipped">The quantity of the Item to be shipped.</param>    /// <param name="QtyToBeShippedBase">The base quantity of the Item to be shipped.</param>    /// <param name="QtyToBeInvoiced">The quantity of the Item to be invoiced.</param>    /// <param name="QtyToBeInvoicedBase">The base quantity of the Item to be invoiced.</param>    /// <param name="ItemLedgShptEntryNo">Item Shipment Entry No. to be assigned to the Item Journal Line.</param>    /// <param name="ItemChargeNo">Item Charge No. to be assigned to the Item Journal Line.</param>    /// <param name="TrackingSpecification">Tracking Specification for the sales line. This parameter is exposed through events, but isn't directly used in the procedure</param>    /// <param name="IsATO">A flag indicating whether the Item is Assemble-to-order.</param>    procedure PostItemJnlLinePrepareJournalLine(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; ItemLedgShptEntryNo: Integer; ItemChargeNo: Code[20]; TrackingSpecification: Record "Tracking Specification"; IsATO: Boolean)    var        DummyItemTrackingSetup: Record "Item Tracking Setup";        IsHandled: Boolean;    begin        ClearRemAmtIfNotItemJnlRollRndg(SalesLine);        ItemJnlLine.Init();        ItemJnlLine.CopyFromSalesHeader(SalesHeader);        ItemJnlLine.CopyFromSalesLine(SalesLine);        ItemJnlLine."Country/Region Code" := GetCountryCode(SalesLine, SalesHeader);        OnPostItemJnlLineOnBeforeCopyTrackingFromSpec(            TrackingSpecification, ItemJnlLine, SalesHeader, SalesLine, SalesInvHeader, SalesCrMemoHeader, IsATO);        ItemJnlLine.CopyTrackingFromSpec(TrackingSpecification);        OnPostItemJnlLineOnAfterCopyTrackingFromSpec(ItemJnlLine, SalesLine, QtyToBeShipped, IsATO);        ItemJnlLine."Item Shpt. Entry No." := ItemLedgShptEntryNo;        IsHandled := false;        OnPostItemJnlLinePrepareJournalLineOnBeforeCalcQuantities(            ItemJnlLine, SalesLine, QtyToBeShipped, QtyToBeShippedBase, QtyToBeInvoiced, QtyToBeInvoicedBase, IsHandled, IsATO);        if not IsHandled then begin            ItemJnlLine.Quantity := -QtyToBeShipped;            ItemJnlLine."Quantity (Base)" := -QtyToBeShippedBase;            ItemJnlLine."Invoiced Quantity" := -QtyToBeInvoiced;            ItemJnlLine."Invoiced Qty. (Base)" := -QtyToBeInvoicedBase;        end;        PostItemJnlLineCopyDocumentFields(ItemJnlLine, SalesHeader, SalesLine, QtyToBeShipped, QtyToBeInvoiced);        if QtyToBeInvoiced <> 0 then            ItemJnlLine."Invoice No." := GenJnlLineDocNo;        ItemJnlLine."Assemble to Order" := IsATO;        if ItemJnlLine."Assemble to Order" then            ItemJnlLine."Applies-to Entry" := SalesLine.FindOpenATOEntry(DummyItemTrackingSetup)        else            ItemJnlLine."Applies-to Entry" := SalesLine."Appl.-to Item Entry";        if ItemChargeNo <> '' then begin            ItemJnlLine."Item Charge No." := ItemChargeNo;            SalesLine."Qty. to Invoice" := QtyToBeInvoiced;            OnPostItemJnlLineOnAfterCopyItemCharge(ItemJnlLine, TempItemChargeAssgntSales);        end else            ItemJnlLine."Applies-from Entry" := SalesLine."Appl.-from Item Entry";        OnPostItemJnlLinePrepareJournalLineOnBeforeCalcItemJnlAmounts(ItemJnlLine, SalesHeader, SalesLine, IsATO);        if QtyToBeInvoiced <> 0 then            CalcItemJnlAmountsFromQtyToBeInvoiced(ItemJnlLine, SalesHeader, SalesLine, QtyToBeInvoiced)        else            CalcItemJnlAmountsFromQtyToBeShipped(ItemJnlLine, SalesHeader, SalesLine, QtyToBeShipped);        OnPostItemJnlLineOnAfterPrepareItemJnlLine(            ItemJnlLine, SalesLine, SalesHeader, WhseShip, ItemJnlPostLine, QtyToBeShipped, TrackingSpecification,            QtyToBeInvoiced, QtyToBeInvoicedBase, QtyToBeShippedBase, RemAmt, RemDiscAmt);    end;    local procedure CalcItemJnlAmountsFromQtyToBeInvoiced(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal)    var        Factor: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcItemJnlAmountsFromQtyToBeInvoiced(ItemJnlLine, SalesHeader, SalesLine, QtyToBeInvoiced, IsHandled);        if IsHandled then            exit;        Factor := QtyToBeInvoiced / SalesLine."Qty. to Invoice";        OnCalcItemJnlAmountsFromQtyToBeInvoicedOnAfterSetFactor(SalesLine, Factor, ItemJnlLine);        ItemJnlLine.Amount := -(SalesLine.Amount * Factor - RemAmt);        if SalesHeader."Prices Including VAT" then            ItemJnlLine."Discount Amount" :=              -((SalesLine."Line Discount Amount" + SalesLine."Inv. Discount Amount") /                (1 + SalesLine."VAT %" / 100) * Factor - RemDiscAmt)        else            ItemJnlLine."Discount Amount" :=              -((SalesLine."Line Discount Amount" + SalesLine."Inv. Discount Amount") *                Factor - RemDiscAmt);        RemAmt := ItemJnlLine.Amount - Round(ItemJnlLine.Amount);        RemDiscAmt := ItemJnlLine."Discount Amount" - Round(ItemJnlLine."Discount Amount");        ItemJnlLine.Amount := Round(ItemJnlLine.Amount);        ItemJnlLine."Discount Amount" := Round(ItemJnlLine."Discount Amount");    end;    local procedure CalcItemJnlAmountsFromQtyToBeShipped(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal)    var        InvDiscAmountPerShippedQty: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcItemJnlAmountsFromQtyToBeShipped(ItemJnlLine, SalesHeader, SalesLine, QtyToBeShipped, IsHandled, InvDiscAmountPerShippedQty, RemAmt);        if IsHandled then            exit;        InvDiscAmountPerShippedQty := Abs(SalesLine."Inv. Discount Amount") * QtyToBeShipped / SalesLine.Quantity;        ItemJnlLine.Amount := QtyToBeShipped * SalesLine."Unit Price";        if SalesHeader."Prices Including VAT" then            ItemJnlLine.Amount :=              -((ItemJnlLine.Amount * (1 - SalesLine."Line Discount %" / 100) - InvDiscAmountPerShippedQty) /                (1 + SalesLine."VAT %" / 100) - RemAmt)        else            ItemJnlLine.Amount :=              -(ItemJnlLine.Amount * (1 - SalesLine."Line Discount %" / 100) - InvDiscAmountPerShippedQty - RemAmt);        RemAmt := ItemJnlLine.Amount - Round(ItemJnlLine.Amount);        if SalesHeader."Currency Code" <> '' then            ItemJnlLine.Amount :=              Round(                CurrExchRate.ExchangeAmtFCYToLCY(                  SalesHeader."Posting Date", SalesHeader."Currency Code",                  ItemJnlLine.Amount, SalesHeader."Currency Factor"))        else            ItemJnlLine.Amount := Round(ItemJnlLine.Amount);    end;    /// <summary>    /// Gets global document headers that were created during posting    /// </summary>    /// <param name="NewSalesShptHeader">Return value: Sales Shipment Header</param>    /// <param name="NewSalesInvHeader">Return value: Sales Invoice Header</param>    /// <param name="NewSalesCrMemoHeader">Return value: Sales Credit Memo Header</param>    /// <param name="NewReturnRcptHeader">Return value: Return Receipt Header</param>    procedure GetGlobaDocumentsHeaders(var NewSalesShptHeader: Record "Sales Shipment Header"; var NewSalesInvHeader: Record "Sales Invoice Header"; var NewSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var NewReturnRcptHeader: Record "Return Receipt Header")    begin        NewSalesShptHeader := SalesShptHeader;        NewSalesInvHeader := SalesInvHeader;        NewReturnRcptHeader := ReturnRcptHeader;        NewSalesCrMemoHeader := SalesCrMemoHeader;    end;    /// <summary>    /// Gets global warehouse posting flags that were set during posting    /// </summary>    /// <param name="NewWhseShip">Return value: Warehouse Shipment</param>    /// <param name="NewWhseReceive">Return value: Warehouse Receipt</param>    /// <param name="NewInvtPickPutaway">Return value: Inventory Pick/Put-Away</param>    procedure GetGlobalWhseFlags(var NewWhseShip: Boolean; var NewWhseReceive: Boolean; var NewInvtPickPutaway: Boolean)    begin        NewWhseShip := WhseShip;        NewWhseReceive := WhseReceive;        NewInvtPickPutaway := InvtPickPutaway;    end;    /// <summary>    /// Gets the Temp Set of Invoiced Tracking Specification lines    /// </summary>    /// <remarks>    /// When Tracking Specification is posted for the line, if line is invoiced (Qty. to Invoice is not 0), the line's tracking information is stored in this buffer    /// </remarks>    /// <param name="NewTempTrackingSpecificationInv">Return value: Temp Tracking Specification lines that were Invoiced</param>    procedure GetGlobalTempTrackingSpecificationInv(var NewTempTrackingSpecificationInv: Record "Tracking Specification" temporary)    begin        NewTempTrackingSpecificationInv.Copy(TempTrackingSpecificationInv, true);    end;    /// <summary>    /// Gets the Temp Set of Posted Tracking Specification lines that were posted for the document    /// </summary>    /// <param name="NewTempTrackingSpecification">Return value: Temp Tracking Specification lines that were Posted</param>    procedure GetGlobalTempTrackingSpecification(var NewTempTrackingSpecification: Record "Tracking Specification" temporary)    begin        NewTempTrackingSpecification.Copy(TempTrackingSpecification, true);    end;    /// <summary>    /// Gets the Source Code that was used during posting    /// </summary>    /// <param name="NewSrcCode">Return value: Source Code</param>    procedure GetGlobalSrcCode(var NewSrcCode: Code[10])    begin        NewSrcCode := SrcCode;    end;    local procedure ClearRemAmtIfNotItemJnlRollRndg(SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeClearRemAmtIfNotItemJnlRollRndg(SalesLine, ItemJnlRollRndg, RemAmt, RemDiscAmt, IsHandled);        if IsHandled then            exit;        if not ItemJnlRollRndg then begin            RemAmt := 0;            RemDiscAmt := 0;        end;    end;    local procedure PostItemJnlLineCopyDocumentFields(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeInvoiced: Decimal)    var        QtyToBeShippedIsZero: Boolean;    begin        QtyToBeShippedIsZero := QtyToBeShipped = 0;        OnBeforePostItemJnlLineCopyDocumentFields(SalesHeader, QtyToBeShipped, QtyToBeShippedIsZero);        if QtyToBeShippedIsZero then            if SalesLine.IsCreditDocType() then                ItemJnlLine.CopyDocumentFields(                  ItemJnlLine."Document Type"::"Sales Credit Memo", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series")            else                ItemJnlLine.CopyDocumentFields(                  ItemJnlLine."Document Type"::"Sales Invoice", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series")        else begin            if SalesLine.IsCreditDocType() then                ItemJnlLine.CopyDocumentFields(                  ItemJnlLine."Document Type"::"Sales Return Receipt",                  ReturnRcptHeader."No.", ReturnRcptHeader."External Document No.", SrcCode, ReturnRcptHeader."No. Series")            else                ItemJnlLine.CopyDocumentFields(                  ItemJnlLine."Document Type"::"Sales Shipment", SalesShptHeader."No.", SalesShptHeader."External Document No.", SrcCode,                  SalesShptHeader."No. Series");            if QtyToBeInvoiced <> 0 then begin                if ItemJnlLine."Document No." = '' then                    if SalesLine."Document Type" = SalesLine."Document Type"::"Credit Memo" then                        ItemJnlLine.CopyDocumentFields(                          ItemJnlLine."Document Type"::"Sales Credit Memo", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series")                    else                        ItemJnlLine.CopyDocumentFields(                          ItemJnlLine."Document Type"::"Sales Invoice", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series");                ItemJnlLine."Posting No. Series" := SalesHeader."Posting No. Series";            end;        end;        OnPostItemJnlLineOnAfterCopyDocumentFields(ItemJnlLine, SalesLine, TempWhseRcptHeader, TempWhseShptHeader);    end;    /// <summary>    /// Posts Item Charges for a sales line    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being posted.</param>    /// <param name="OriginalItemJnlLine">The original Item Journal Line that was posted for the sales line. It servers as the basis for Item Journal Lines that are created for Item Charges.</param>    /// <param name="ItemShptEntryNo">Item Shipment Entry No. that is assigned to journal lines for Item Charges.</param>    procedure PostItemJnlLineItemCharges(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var OriginalItemJnlLine: Record "Item Journal Line"; ItemShptEntryNo: Integer)    var        ItemChargeSalesLine: Record "Sales Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemJnlLineItemCharges(SalesLine, IsHandled);        if IsHandled then            exit;        ClearItemChargeAssgntFilter();        TempItemChargeAssgntSales.SetCurrentKey(          "Applies-to Doc. Type", "Applies-to Doc. No.", "Applies-to Doc. Line No.");        TempItemChargeAssgntSales.SetRange("Applies-to Doc. Type", SalesLine."Document Type");        TempItemChargeAssgntSales.SetRange("Applies-to Doc. No.", SalesLine."Document No.");        TempItemChargeAssgntSales.SetRange("Applies-to Doc. Line No.", SalesLine."Line No.");        if TempItemChargeAssgntSales.FindSet() then            repeat                SalesLine.TestField("Allow Item Charge Assignment");                GetItemChargeLine(SalesHeader, ItemChargeSalesLine);                OnPostItemJnlLineItemChargesOnAfterGetItemChargeLine(ItemChargeSalesLine, SalesLine);                ItemChargeSalesLine.CalcFields("Qty. Assigned");                if (ItemChargeSalesLine."Qty. to Invoice" <> 0) or                   (Abs(ItemChargeSalesLine."Qty. Assigned") < Abs(ItemChargeSalesLine."Quantity Invoiced"))                then begin                    OriginalItemJnlLine."Item Shpt. Entry No." := ItemShptEntryNo;                    PostItemChargePerOrder(SalesHeader, SalesLine, OriginalItemJnlLine, ItemChargeSalesLine);                    TempItemChargeAssgntSales.Mark(true);                end;            until TempItemChargeAssgntSales.Next() = 0;    end;    /// <summary>    /// Adds Tracking Specification for a sales line to the global temp tables where it will later be posted from    /// </summary>    /// <remarks>    /// If line is being invoiced, it's additionally stored in TempTrackingSpecificationInv,    /// and if Warehouse Journal Lines are being posted, it's also stored in TempWhseTrackingSpecification    /// </remarks>    /// <param name="SalesLine">The sales line of the document line that is being posted.</param>    /// <param name="TempWhseTrackingSpecification">Return value: Temp Tracking Specification lines realted to Warehouse Journal Lines</param>    /// <param name="PostWhseJnlLine">A flag indicating whether Warehouse Journal Lines should be posted for the sales line.</param>    /// <param name="QtyToBeInvoiced">The quantity of the Item to be invoiced.</param>    /// <param name="TempTrackingSpec">Return value: Temp Tracking Specification lines related to the Item Journal Line</param>    procedure PostItemJnlLineTracking(SalesLine: Record "Sales Line"; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary; PostWhseJnlLine: Boolean; QtyToBeInvoiced: Decimal; var TempTrackingSpec: Record "Tracking Specification" temporary)    var        ShouldInsertTrkgSpecInv: Boolean;    begin        if ItemJnlPostLine.CollectTrackingSpecification(TempTrackingSpec) then            if TempTrackingSpec.FindSet() then                repeat                    TempTrackingSpecification := TempTrackingSpec;                    TempTrackingSpecification.SetSourceFromSalesLine(SalesLine);                    OnPostItemJnlLineTrackingOnBeforeInsertTempTrkgSpec(TempTrackingSpecification, TempTrackingSpec, SalesLine);                    if TempTrackingSpecification.Insert() then;                    ShouldInsertTrkgSpecInv := QtyToBeInvoiced <> 0;                    OnPostItemJnlLineTrackingOnAfterCalcShouldInsertTrkgSpecInv(SalesLine, QtyToBeInvoiced, ShouldInsertTrkgSpecInv); // <-- NEW EVENT                    if ShouldInsertTrkgSpecInv then begin                        TempTrackingSpecificationInv := TempTrackingSpecification;                        if TempTrackingSpecificationInv.Insert() then;                    end;                    if PostWhseJnlLine then begin                        TempWhseTrackingSpecification := TempTrackingSpecification;                        if TempWhseTrackingSpecification.Insert() then;                    end;                until TempTrackingSpec.Next() = 0;    end;    /// <summary>    /// Splits the incoming Warehouse Journal Line into more lines if tracking is required and posts them    /// </summary>    /// <param name="TempWhseJnlLine">The Warehouse Journal Line to be posted.</param>    /// <param name="TempWhseTrackingSpecification">The Tracking Specification Record Set for the Warehouse Journal Line.</param>    procedure PostItemJnlLineWhseLine(var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary)    var        TempWhseJnlLine2: Record "Warehouse Journal Line" temporary;        WMSMgt: Codeunit "WMS Management";    begin        OnBeforePostItemJournalLineWarehouseLine(TempWhseJnlLine, TempWhseTrackingSpecification);        ItemTrackingMgt.SplitWhseJnlLine(TempWhseJnlLine, TempWhseJnlLine2, TempWhseTrackingSpecification, false);        if TempWhseJnlLine2.FindSet() then            repeat                OnPostItemJnlLineWhseLineOnBeforePostTempWhseJnlLine2(TempWhseJnlLine2, WhseShip, WhseReceive, InvtPickPutaway);                if TempWhseJnlLine2."Location Code" <> '' then                    WMSMgt.CheckWhseJnlLine(TempWhseJnlLine2, 1, 0, false);                WhseJnlPostLine.Run(TempWhseJnlLine2);            until TempWhseJnlLine2.Next() = 0;        TempWhseTrackingSpecification.DeleteAll();        OnAfterPostItemJournalLineWarehouseLine(TempWhseJnlLine, TempWhseTrackingSpecification);    end;    /// <summary>    /// Prepares Warehouse Journal Line and Reservation Entries for later posting    /// </summary>    /// <param name="ItemJnlLine">The Item Journal Line to be posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being posted.</param>    /// <param name="TempWhseJnlLine">Return value: The Warehouse Journal Line information that gets populated if the sales line requires Warehouse Journal Line to be posted.</param>    /// <param name="PostWhseJnlLine">Return value: A flag indicating whether Warehouse Journal Lines should be posted for the sales line.</param>    /// <param name="QtyToBeShippedBase">The base quantity of the Item to be shipped.</param>    /// <param name="TrackingSpecification">Tracking Specification for the sales line. This parameter is exposed through events, but isn't directly used in the procedure</param>    procedure PostItemJnlLineBeforePost(var ItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; var PostWhseJnlLine: Boolean; QtyToBeShippedBase: Decimal; TrackingSpecification: Record "Tracking Specification")    var        CheckApplFromItemEntry: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemJnlLineBeforePost(SalesLine, ItemJnlLine, TempWhseJnlLine, Location, PostWhseJnlLine, QtyToBeShippedBase, IsHandled, TrackingSpecification);        if IsHandled then            exit;        if SalesSetup."Exact Cost Reversing Mandatory" and (SalesLine.Type = SalesLine.Type::Item) then            if SalesLine.IsCreditDocType() then                CheckApplFromItemEntry := SalesLine.Quantity > 0            else                CheckApplFromItemEntry := SalesLine.Quantity < 0;        if (SalesLine."Location Code" <> '') and (SalesLine.Type = SalesLine.Type::Item) and (ItemJnlLine.Quantity <> 0) then            if ShouldPostWhseJnlLine(SalesLine) then begin                CreateWhseJnlLine(ItemJnlLine, SalesLine, TempWhseJnlLine);                PostWhseJnlLine := true;            end;        OnPostItemJnlLineOnBeforeTransferReservToItemJnlLine(SalesLine, ItemJnlLine, CheckApplFromItemEntry, TrackingSpecification, QtyToBeShippedBase);        if QtyToBeShippedBase <> 0 then begin            if SalesLine.IsCreditDocType() then                SalesLineReserve.TransferSalesLineToItemJnlLine(SalesLine, ItemJnlLine, QtyToBeShippedBase, CheckApplFromItemEntry, false)            else                TransferReservToItemJnlLine(                  SalesLine, ItemJnlLine, -QtyToBeShippedBase, TempTrackingSpecification, CheckApplFromItemEntry);            if CheckApplFromItemEntry and SalesLine.IsInventoriableItem() then                SalesLine.TestField("Appl.-from Item Entry");        end;        OnAfterPostItemJnlLineBeforePost(ItemJnlLine, SalesLine, QtyToBeShippedBase, ItemJnlPostLine, CheckApplFromItemEntry, TrackingSpecification);    end;    /// <summary>    /// Checks wheter a Warehouse Journal Line should be posted for a sales line    /// </summary>    /// <param name="SalesLine">The sales line for which the check is performed.</param>    /// <returns>true if a Warehouse Journal Line should be posted for the sales line; otherwise, false.</returns>    procedure ShouldPostWhseJnlLine(SalesLine: Record "Sales Line") Result: Boolean    var        IsHandled: Boolean;    begin        OnBeforeShouldPostWhseJnlLine(SalesLine, Result, IsHandled);        if IsHandled then            exit(Result);        if SalesLine.IsInventoriableItem() then begin            GetLocation(SalesLine."Location Code");            if ((SalesLine."Document Type" in [SalesLine."Document Type"::Invoice, SalesLine."Document Type"::"Credit Memo"]) and                Location."Directed Put-away and Pick") or               (Location."Bin Mandatory" and not (WhseShip or WhseReceive or InvtPickPutaway or SalesLine."Drop Shipment"))            then                exit(true);        end;        exit(false);    end;    local procedure PostItemChargePerOrder(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; ItemJnlLine2: Record "Item Journal Line"; ItemChargeSalesLine: Record "Sales Line")    var        NonDistrItemJnlLine: Record "Item Journal Line";        QtyToInvoice: Decimal;        Factor: Decimal;        OriginalAmt: Decimal;        OriginalDiscountAmt: Decimal;        OriginalQty: Decimal;        SignFactor: Integer;        IsHandled: Boolean;    begin        OnBeforePostItemChargePerOrder(SalesHeader, SalesLine, ItemJnlLine2, ItemChargeSalesLine, SuppressCommit);        IsHandled := false;        OnPostItemChargePerOrderOnBeforeTestJobNo(SalesLine, IsHandled);        if not IsHandled then            SalesLine.TestField("Job No.", '');        SalesLine.TestField("Allow Item Charge Assignment", true);        ItemJnlLine2."Document No." := GenJnlLineDocNo;        ItemJnlLine2."External Document No." := GenJnlLineExtDocNo;        ItemJnlLine2."Item Charge No." := TempItemChargeAssgntSales."Item Charge No.";        ItemJnlLine2.Description := ItemChargeSalesLine.Description;        ItemJnlLine2."Unit of Measure Code" := '';        ItemJnlLine2."Qty. per Unit of Measure" := 1;        ItemJnlLine2."Applies-from Entry" := 0;        if TempItemChargeAssgntSales."Document Type" in [TempItemChargeAssgntSales."Document Type"::"Return Order", TempItemChargeAssgntSales."Document Type"::"Credit Memo"] then            QtyToInvoice :=              CalcQtyToInvoice(SalesLine."Return Qty. to Receive (Base)", SalesLine."Qty. to Invoice (Base)")        else            QtyToInvoice :=              CalcQtyToInvoice(SalesLine."Qty. to Ship (Base)", SalesLine."Qty. to Invoice (Base)");        if ItemJnlLine2."Invoiced Quantity" = 0 then begin            ItemJnlLine2."Invoiced Quantity" := ItemJnlLine2.Quantity;            ItemJnlLine2."Invoiced Qty. (Base)" := ItemJnlLine2."Quantity (Base)";        end;        ItemJnlLine2."Document Line No." := ItemChargeSalesLine."Line No.";        ItemJnlLine2.Amount := TempItemChargeAssgntSales."Amount to Handle" * ItemJnlLine2."Invoiced Qty. (Base)" / QtyToInvoice;        if TempItemChargeAssgntSales."Document Type" in [TempItemChargeAssgntSales."Document Type"::"Return Order", TempItemChargeAssgntSales."Document Type"::"Credit Memo"] then            ItemJnlLine2.Amount := -ItemJnlLine2.Amount;        ItemJnlLine2."Unit Cost (ACY)" :=          Round(ItemJnlLine2.Amount / ItemJnlLine2."Invoiced Qty. (Base)",            Currency."Unit-Amount Rounding Precision");        PreciseTotalChargeAmt += ItemJnlLine2.Amount;        if SalesHeader."Currency Code" <> '' then            ItemJnlLine2.Amount :=              CurrExchRate.ExchangeAmtFCYToLCY(                SalesHeader.GetUseDate(), SalesHeader."Currency Code", PreciseTotalChargeAmt + TotalSalesLine.Amount, SalesHeader."Currency Factor") -              RoundedPrevTotalChargeAmt - TotalSalesLineLCY.Amount        else            ItemJnlLine2.Amount := PreciseTotalChargeAmt - RoundedPrevTotalChargeAmt;        RoundedPrevTotalChargeAmt += Round(ItemJnlLine2.Amount, GLSetup."Amount Rounding Precision");        ItemJnlLine2."Unit Cost" := Round(            ItemJnlLine2.Amount / ItemJnlLine2."Invoiced Qty. (Base)", GLSetup."Unit-Amount Rounding Precision");        ItemJnlLine2."Applies-to Entry" := ItemJnlLine2."Item Shpt. Entry No.";        if SalesHeader."Currency Code" <> '' then            ItemJnlLine2."Discount Amount" := Round(                CurrExchRate.ExchangeAmtFCYToLCY(                  SalesHeader.GetUseDate(), SalesHeader."Currency Code",                  (ItemChargeSalesLine."Inv. Discount Amount" + ItemChargeSalesLine."Line Discount Amount") *                  ItemJnlLine2."Invoiced Qty. (Base)" / ItemChargeSalesLine."Quantity (Base)" *                  TempItemChargeAssgntSales."Qty. to Handle" / QtyToInvoice,                  SalesHeader."Currency Factor"),                GLSetup."Amount Rounding Precision")        else            ItemJnlLine2."Discount Amount" := Round(                (ItemChargeSalesLine."Inv. Discount Amount" + ItemChargeSalesLine."Line Discount Amount") *                ItemJnlLine2."Invoiced Qty. (Base)" / ItemChargeSalesLine."Quantity (Base)" *                TempItemChargeAssgntSales."Qty. to Handle" / QtyToInvoice,                GLSetup."Amount Rounding Precision");        if SalesLine.IsCreditDocType() then            ItemJnlLine2."Discount Amount" := -ItemJnlLine2."Discount Amount";        ItemJnlLine2."Shortcut Dimension 1 Code" := ItemChargeSalesLine."Shortcut Dimension 1 Code";        ItemJnlLine2."Shortcut Dimension 2 Code" := ItemChargeSalesLine."Shortcut Dimension 2 Code";        ItemJnlLine2."Dimension Set ID" := ItemChargeSalesLine."Dimension Set ID";        UpdateItemJnlLineDimSetIDFromAppliedShipmentEntry(ItemJnlLine2);        ItemJnlLine2."Gen. Prod. Posting Group" := ItemChargeSalesLine."Gen. Prod. Posting Group";        OnPostItemChargePerOrderOnAfterCopyToItemJnlLine(          ItemJnlLine2, ItemChargeSalesLine, GLSetup, QtyToInvoice, TempItemChargeAssgntSales);        TempTrackingSpecificationInv.Reset();        TempTrackingSpecificationInv.SetRange("Source Type", DATABASE::"Sales Line");        TempTrackingSpecificationInv.SetRange("Source ID", TempItemChargeAssgntSales."Applies-to Doc. No.");        TempTrackingSpecificationInv.SetRange("Source Ref. No.", TempItemChargeAssgntSales."Applies-to Doc. Line No.");        IsHandled := false;        OnPostItemChargePerOrderOnAfterTempTrackingSpecificationInvSetFilters(SalesHeader, ItemJnlLine2, TempTrackingSpecificationInv, SalesLine, IsHandled, TotalSalesLineLCY, TotalSalesLine);        if not IsHandled then            if TempTrackingSpecificationInv.IsEmpty() then                RunItemJnlPostLine(ItemJnlLine2)            else begin                TempTrackingSpecificationInv.FindSet();                NonDistrItemJnlLine := ItemJnlLine2;                OriginalAmt := NonDistrItemJnlLine.Amount;                OriginalDiscountAmt := NonDistrItemJnlLine."Discount Amount";                OriginalQty := NonDistrItemJnlLine."Quantity (Base)";                if (TempTrackingSpecificationInv."Quantity (Base)" / OriginalQty) > 0 then                    SignFactor := 1                else                    SignFactor := -1;                repeat                    Factor := TempTrackingSpecificationInv."Quantity (Base)" / OriginalQty * SignFactor;                    if Abs(TempTrackingSpecificationInv."Quantity (Base)") < Abs(NonDistrItemJnlLine."Quantity (Base)") then begin                        ItemJnlLine2."Quantity (Base)" := -TempTrackingSpecificationInv."Quantity (Base)";                        ItemJnlLine2."Invoiced Qty. (Base)" := ItemJnlLine2."Quantity (Base)";                        if SalesHeader."Currency Code" <> '' then begin                            PreciseTotalChargeAmt +=                              CurrExchRate.ExchangeAmtLCYToFCY(                                SalesHeader.GetUseDate(), SalesHeader."Currency Code", OriginalAmt * Factor, SalesHeader."Currency Factor");                            ItemJnlLine2.Amount :=                              CurrExchRate.ExchangeAmtFCYToLCY(                                SalesHeader.GetUseDate(), SalesHeader."Currency Code", PreciseTotalChargeAmt + TotalSalesLine.Amount, SalesHeader."Currency Factor") -                              RoundedPrevTotalChargeAmt - TotalSalesLineLCY.Amount;                        end else begin                            PreciseTotalChargeAmt += OriginalAmt * Factor;                            ItemJnlLine2.Amount := PreciseTotalChargeAmt - RoundedPrevTotalChargeAmt;                        end;                        ItemJnlLine2.Amount :=                            Round(ItemJnlLine2.Amount, GLSetup."Amount Rounding Precision");                        RoundedPrevTotalChargeAmt += ItemJnlLine2.Amount;                        ItemJnlLine2."Discount Amount" :=                          Round(OriginalDiscountAmt * Factor, GLSetup."Amount Rounding Precision");                        ItemJnlLine2."Unit Cost" :=                          Round(ItemJnlLine2.Amount / ItemJnlLine2."Invoiced Qty. (Base)",                            GLSetup."Unit-Amount Rounding Precision") * SignFactor;                        ItemJnlLine2."Item Shpt. Entry No." := TempTrackingSpecificationInv."Item Ledger Entry No.";                        ItemJnlLine2."Applies-to Entry" := TempTrackingSpecificationInv."Item Ledger Entry No.";                        ItemJnlLine2.CopyTrackingFromSpec(TempTrackingSpecificationInv);                        IsHandled := false;                        OnPostItemChargePerOrderOnBeforeRunWithCheck(ItemJnlLine2, IsHandled, SalesLine);                        if not IsHandled then                            RunItemJnlPostLine(ItemJnlLine2);                        ItemJnlLine2."Location Code" := NonDistrItemJnlLine."Location Code";                        NonDistrItemJnlLine."Quantity (Base)" -= ItemJnlLine2."Quantity (Base)";                        NonDistrItemJnlLine.Amount -= ItemJnlLine2.Amount;                        NonDistrItemJnlLine."Discount Amount" -= ItemJnlLine2."Discount Amount";                    end else begin // the last time                        NonDistrItemJnlLine."Quantity (Base)" := -TempTrackingSpecificationInv."Quantity (Base)";                        NonDistrItemJnlLine."Invoiced Qty. (Base)" := -TempTrackingSpecificationInv."Quantity (Base)";                        NonDistrItemJnlLine."Unit Cost" :=                          Round(NonDistrItemJnlLine.Amount / NonDistrItemJnlLine."Invoiced Qty. (Base)",                            GLSetup."Unit-Amount Rounding Precision");                        NonDistrItemJnlLine."Item Shpt. Entry No." := TempTrackingSpecificationInv."Item Ledger Entry No.";                        NonDistrItemJnlLine."Applies-to Entry" := TempTrackingSpecificationInv."Item Ledger Entry No.";                        NonDistrItemJnlLine.CopyTrackingFromSpec(TempTrackingSpecificationInv);                        IsHandled := false;                        OnPostItemChargePerOrderOnBeforeLastRunWithCheck(NonDistrItemJnlLine, SalesLine, IsHandled);                        if not IsHandled then                            RunItemJnlPostLine(NonDistrItemJnlLine);                        NonDistrItemJnlLine."Location Code" := ItemJnlLine2."Location Code";                    end;                until TempTrackingSpecificationInv.Next() = 0;            end;    end;    /// <summary>    /// Checks if Item Charge should be distributed across multiple Item Ledger Entries and posts the charges    /// </summary>    /// <remarks>    /// If Sales Shipment Line doesn't exist for the Item Charge Line of the sales line, an error is raised within CheckItemChargePerShpt().    /// If no related Item Ledger Entries are found for the sales line, an error is raised.    /// </remarks>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being posted.</param>    procedure PostItemChargePerShpt(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")    var        SalesShptLine: Record "Sales Shipment Line";        TempItemLedgEntry: Record "Item Ledger Entry" temporary;        ItemTrackingMgt: Codeunit "Item Tracking Management";        DistributeCharge: Boolean;        IsHandled: Boolean;    begin        CheckItemChargePerShpt(SalesShptLine, SalesLine);        IsHandled := false;        OnPostItemChargePerShptOnAfterCheckItemChargePerShpt(SalesShptLine, TempItemChargeAssgntSales, DistributeCharge, IsHandled, SalesHeader, SalesLine);        if IsHandled then            exit;        if SalesShptLine."Item Shpt. Entry No." <> 0 then            DistributeCharge :=              CostCalcMgt.SplitItemLedgerEntriesExist(                TempItemLedgEntry, -SalesShptLine."Quantity (Base)", SalesShptLine."Item Shpt. Entry No.")        else begin            DistributeCharge := true;            if not ItemTrackingMgt.CollectItemEntryRelation(TempItemLedgEntry,                 DATABASE::"Sales Shipment Line", 0, SalesShptLine."Document No.",                 '', 0, SalesShptLine."Line No.", -SalesShptLine."Quantity (Base)")            then                Error(RelatedItemLedgEntriesNotFoundErr);        end;        IsHandled := false;        OnPostItemChargePerShptOnAfterCalcDistributeCharge(SalesHeader, SalesLine, SalesShptLine, TempItemLedgEntry, TempItemChargeAssgntSales, DistributeCharge, IsHandled);        if not IsHandled then            if DistributeCharge then                PostDistributeItemCharge(                    SalesHeader, SalesLine, TempItemLedgEntry, SalesShptLine."Quantity (Base)",                    TempItemChargeAssgntSales."Qty. to Handle", TempItemChargeAssgntSales."Amount to Handle")            else                PostItemCharge(                    SalesHeader, SalesLine, SalesShptLine."Item Shpt. Entry No.", SalesShptLine."Quantity (Base)",                    TempItemChargeAssgntSales."Amount to Handle", TempItemChargeAssgntSales."Qty. to Handle");    end;    local procedure CheckItemChargePerShpt(var SalesShptLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        if not SalesShptLine.Get(            TempItemChargeAssgntSales."Applies-to Doc. No.", TempItemChargeAssgntSales."Applies-to Doc. Line No.")        then            Error(ShipmentLinesDeletedErr);        IsHandled := false;        OnPostItemChargePerShptOnBeforeTestJobNo(SalesShptLine, IsHandled, SalesLine);        if not IsHandled then            SalesShptLine.TestField("Job No.", '');    end;    local procedure PostItemChargePerRetRcpt(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")    var        ReturnRcptLine: Record "Return Receipt Line";        TempItemLedgEntry: Record "Item Ledger Entry" temporary;        ItemTrackingMgt: Codeunit "Item Tracking Management";        DistributeCharge: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemChargePerRetRcpt(SalesHeader, SalesLine, TempItemChargeAssgntSales, IsHandled);        if IsHandled then            exit;        if not ReturnRcptLine.Get(             TempItemChargeAssgntSales."Applies-to Doc. No.", TempItemChargeAssgntSales."Applies-to Doc. Line No.")        then            Error(ShipmentLinesDeletedErr);        IsHandled := false;        OnPostItemChargePerRetRcptOnBeforeTestFieldJobNo(ReturnRcptLine, IsHandled, SalesLine);        if not IsHandled then            ReturnRcptLine.TestField("Job No.", '');        if ReturnRcptLine."Item Rcpt. Entry No." <> 0 then            DistributeCharge :=              CostCalcMgt.SplitItemLedgerEntriesExist(                TempItemLedgEntry, ReturnRcptLine."Quantity (Base)", ReturnRcptLine."Item Rcpt. Entry No.")        else begin            DistributeCharge := true;            if not ItemTrackingMgt.CollectItemEntryRelation(TempItemLedgEntry,                 DATABASE::"Return Receipt Line", 0, ReturnRcptLine."Document No.",                 '', 0, ReturnRcptLine."Line No.", ReturnRcptLine."Quantity (Base)")            then                Error(RelatedItemLedgEntriesNotFoundErr);        end;        IsHandled := false;        OnPostItemChargePerRetRcptOnAfterCalcDistributeCharge(SalesHeader, SalesLine, ReturnRcptLine, TempItemLedgEntry, TempItemChargeAssgntSales, DistributeCharge, IsHandled);        if not IsHandled then            if DistributeCharge then                PostDistributeItemCharge(                    SalesHeader, SalesLine, TempItemLedgEntry, ReturnRcptLine."Quantity (Base)",                    TempItemChargeAssgntSales."Qty. to Handle", TempItemChargeAssgntSales."Amount to Handle")            else                PostItemCharge(                    SalesHeader, SalesLine, ReturnRcptLine."Item Rcpt. Entry No.", ReturnRcptLine."Quantity (Base)",                    TempItemChargeAssgntSales."Amount to Handle", TempItemChargeAssgntSales."Qty. to Handle")    end;    /// <summary>    /// Distributes the item charge across Item Ledger Entries and posts the charges    /// </summary>    /// <remarks>    /// Throws an error if no Item Ledger Entries are found in the TempItemLedgerEntry Record Set    /// </remarks>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being posted.</param>    /// <param name="TempItemLedgEntry">Temp Set of Item Ledger Entries to distribute the charge across</param>    /// <param name="NonDistrQuantity">The full quantity, used for calculating the factor for individual Item Ledger Entries</param>    /// <param name="NonDistrQtyToAssign">The full quantity to assign to be distributed</param>    /// <param name="NonDistrAmountToAssign">The full amount to be distributed</param>    procedure PostDistributeItemCharge(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TempItemLedgEntry: Record "Item Ledger Entry" temporary; NonDistrQuantity: Decimal; NonDistrQtyToAssign: Decimal; NonDistrAmountToAssign: Decimal)    var        Factor: Decimal;        QtyToAssign: Decimal;        AmountToAssign: Decimal;        IsHandled: Boolean;    begin        OnBeforePostDistributeItemCharge(SalesHeader, SalesLine, TempItemLedgEntry, NonDistrQuantity, NonDistrQtyToAssign, NonDistrAmountToAssign, IsHandled);        if IsHandled then            exit;        if TempItemLedgEntry.FindSet() then            repeat                Factor := Abs(TempItemLedgEntry.Quantity / NonDistrQuantity);                OnPostDistributeItemChargeOnAfterSetFactor(TempItemLedgEntry, Factor);                QtyToAssign := NonDistrQtyToAssign * Factor;                AmountToAssign := Round(NonDistrAmountToAssign * Factor, GLSetup."Amount Rounding Precision");                if Factor < 1 then begin                    PostItemCharge(SalesHeader, SalesLine,                      TempItemLedgEntry."Entry No.", -TempItemLedgEntry.Quantity,                      AmountToAssign, QtyToAssign);                    NonDistrQuantity := NonDistrQuantity + TempItemLedgEntry.Quantity;                    NonDistrQtyToAssign := NonDistrQtyToAssign - QtyToAssign;                    NonDistrAmountToAssign := NonDistrAmountToAssign - AmountToAssign;                end else // the last time                    PostItemCharge(SalesHeader, SalesLine,                      TempItemLedgEntry."Entry No.", -TempItemLedgEntry.Quantity,                      NonDistrAmountToAssign, NonDistrQtyToAssign);            until TempItemLedgEntry.Next() = 0        else            Error(RelatedItemLedgEntriesNotFoundErr);    end;    /// <summary>    /// Posts an associated item journal line for drop shipment or special order transactions.    /// </summary>    /// <param name="SalesHeader">The sales header record.</param>    /// <param name="SalesLine">The sales line record.</param>    /// <param name="QtyToBeShipped">The quantity to be shipped.</param>    /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param>    /// <returns>The item shipment entry number, or 0 if tracking was handled.</returns>    procedure PostAssocItemJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal): Integer    var        ItemJnlLine: Record "Item Journal Line";        TempHandlingSpecification2: Record "Tracking Specification" temporary;        ItemEntryRelation: Record "Item Entry Relation";        PurchOrderHeader: Record "Purchase Header";        PurchOrderLine: Record "Purchase Line";        IsHandled: Boolean;    begin        PurchOrderHeader.Get(          PurchOrderHeader."Document Type"::Order, SalesLine."Purchase Order No.");        PurchOrderLine.Get(          PurchOrderLine."Document Type"::Order, SalesLine."Purchase Order No.", SalesLine."Purch. Order Line No.");        InitAssocItemJnlLine(ItemJnlLine, PurchOrderHeader, PurchOrderLine, SalesHeader, SalesLine, QtyToBeShipped, QtyToBeShippedBase);        IsHandled := false;        OnPostAssocItemJnlLineOnBeforePost(ItemJnlLine, PurchOrderLine, IsHandled);        if (PurchOrderLine."Job No." = '') or IsHandled then begin            TransferReservFromPurchLine(PurchOrderLine, ItemJnlLine, SalesLine, QtyToBeShippedBase);            IsHandled := false;            OnBeforePostAssocItemJnlLine(ItemJnlLine, PurchOrderLine, SuppressCommit, SalesLine, IsHandled);            if not IsHandled then                RunItemJnlPostLine(ItemJnlLine);            // Handle Item Tracking            if ItemJnlPostLine.CollectTrackingSpecification(TempHandlingSpecification2) then begin                if TempHandlingSpecification2.FindSet() then                    repeat                        TempTrackingSpecification := TempHandlingSpecification2;                        TempTrackingSpecification.SetSourceFromPurchLine(PurchOrderLine);                        if TempTrackingSpecification.Insert() then;                        ItemEntryRelation.InitFromTrackingSpec(TempHandlingSpecification2);                        ItemEntryRelation.SetSource(DATABASE::"Purch. Rcpt. Line", 0, PurchOrderHeader."Receiving No.", PurchOrderLine."Line No.");                        ItemEntryRelation.SetOrderInfo(PurchOrderLine."Document No.", PurchOrderLine."Line No.");                        ItemEntryRelation.Insert();                    until TempHandlingSpecification2.Next() = 0;                exit(0);            end;        end;        exit(ItemJnlLine."Item Shpt. Entry No.");    end;    /// <summary>    /// Initializes an item journal line for associated purchase order posting.    /// </summary>    /// <param name="ItemJnlLine">The item journal line to initialize.</param>    /// <param name="PurchOrderHeader">The purchase order header.</param>    /// <param name="PurchOrderLine">The purchase order line.</param>    /// <param name="SalesHeader">The sales header record.</param>    /// <param name="SalesLine">The sales line record.</param>    /// <param name="QtyToBeShipped">The quantity to be shipped.</param>    /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param>    procedure InitAssocItemJnlLine(var ItemJnlLine: Record "Item Journal Line"; PurchOrderHeader: Record "Purchase Header"; PurchOrderLine: Record "Purchase Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal)    begin        OnBeforeInitAssocItemJnlLine(ItemJnlLine, PurchOrderHeader, PurchOrderLine, SalesHeader, SalesLine);        ItemJnlLine.Init();        ItemJnlLine."Entry Type" := ItemJnlLine."Entry Type"::Purchase;        ItemJnlLine.CopyDocumentFields(          ItemJnlLine."Document Type"::"Purchase Receipt", PurchOrderHeader."Receiving No.", PurchOrderHeader."No.", SrcCode,          PurchOrderHeader."Posting No. Series");        ItemJnlLine.CopyFromPurchHeader(PurchOrderHeader);        ItemJnlLine."Posting Date" := SalesHeader."Posting Date";        ItemJnlLine."Document Date" := SalesHeader."Document Date";        ItemJnlLine.CopyFromPurchLine(PurchOrderLine);        ItemJnlLine.Quantity := QtyToBeShipped;        ItemJnlLine."Quantity (Base)" := QtyToBeShippedBase;        ItemJnlLine."Invoiced Quantity" := 0;        ItemJnlLine."Invoiced Qty. (Base)" := 0;        ItemJnlLine."Source Currency Code" := SalesHeader."Currency Code";        ItemJnlLine.Amount := Round(PurchOrderLine.Amount * QtyToBeShipped / PurchOrderLine.Quantity);        ItemJnlLine."Discount Amount" := PurchOrderLine."Line Discount Amount";        ItemJnlLine."Applies-to Entry" := 0;        OnAfterInitAssocItemJnlLine(ItemJnlLine, PurchOrderHeader, PurchOrderLine, SalesHeader, SalesLine, QtyToBeShipped, QtyToBeShippedBase);    end;    /// <summary>    /// Executes various checks and updates for an Open or Pending Prepayment document and releases it    /// </summary>    /// <remarks>    /// Changes are committed to the database if the PreviewMode flag is not set    /// Open Linked ATOs (Assembly-to-Order documents) are reopened after the document is released    /// </remarks>    /// <param name="SalesHeader">The sales header of the document that is being released.</param>    procedure ReleaseSalesDocument(var SalesHeader: Record "Sales Header")    var        SalesHeaderCopy: Record "Sales Header";        TempAsmHeader: Record "Assembly Header" temporary;        ReleaseSalesDocument: Codeunit "Release Sales Document";        LinesWereModified: Boolean;        SavedStatus: Enum "Sales Document Status";        IsHandled: Boolean;    begin        OnBeforeReleaseSalesDocument(SalesHeader, PreviewMode);        if not (SalesHeader.Status = SalesHeader.Status::Open) or (SalesHeader.Status = SalesHeader.Status::"Pending Prepayment") then            exit;        SalesHeaderCopy := SalesHeader;        SavedStatus := SalesHeader.Status;        GetOpenLinkedATOs(TempAsmHeader);        OnBeforeReleaseSalesDoc(SalesHeader);        LinesWereModified := ReleaseSalesDocument.ReleaseSalesHeader(SalesHeader, PreviewMode);        if LinesWereModified then            RefreshTempLines(SalesHeader, TempSalesLineGlobal);        TestStatusRelease(SalesHeader);        SalesHeader.Status := SavedStatus;        RestoreSalesHeader(SalesHeader, SalesHeaderCopy);        ReopenAsmOrders(TempAsmHeader);        OnAfterReleaseSalesDoc(SalesHeader);        if not (PreviewMode or SuppressCommit) then begin            SalesHeader.Modify();            Commit();        end;        IsHandled := false;        OnReleaseSalesDocumentOnBeforeSetStatus(SalesHeader, IsHandled, SavedStatus, PreviewMode, SuppressCommit);        if not IsHandled then            SalesHeader.Status := SalesHeader.Status::Released;    end;    /// <summary>    /// Checks if status of the document is Released    /// </summary>    /// <param name="SalesHeader">The sales header of the document whose status is being checked.</param>    local procedure TestStatusRelease(SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestStatusRelease(SalesHeader, IsHandled);        if not IsHandled then            SalesHeader.TestField(Status, SalesHeader.Status::Released);    end;    /// <summary>    /// Checks varous sales line fields (quantities, tracking, posting groups) depending on the Type of the Line, to ensure it is valid for posting    /// </summary>    /// <param name="SalesHeader">The sales header of the document that is being posted.</param>    /// <param name="SalesLine">The sales line of the document line that is being tested.</param>    procedure TestSalesLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestSalesLine(SalesHeader, SalesLine, SuppressCommit, IsHandled);        if IsHandled then            exit;        case SalesLine.Type of            SalesLine.Type::Item:                CheckItemTrackingQuantity(SalesLine, SalesHeader);            SalesLine.Type::"Charge (Item)":                TestSalesLineItemCharge(SalesLine);            SalesLine.Type::"Fixed Asset":                TestSalesLineFixedAsset(SalesLine)            else                TestSalesLineOthers(SalesLine);        end;        TestSalesLineJob(SalesLine);        OnTestSalesLineOnAfterTestSalesLineJob(SalesLine);        TestFieldsByDocType(SalesHeader, SalesLine);        CheckBlockedPostingGroups(SalesLine);        OnAfterTestSalesLine(SalesHeader, SalesLine, WhseShip, WhseReceive, SuppressCommit);    end;    local procedure TestFieldsByDocType(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    var        ShouldTestQtyToShip: Boolean;        ShouldTestReturnQty: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestFieldsByDocType(SalesHeader, SalesLine, IsHandled);        if IsHandled then            exit;        case SalesLine."Document Type" of            SalesLine."Document Type"::Order:                SalesLine.TestField("Return Qty. to Receive", 0, ErrorInfo.Create());            SalesLine."Document Type"::Invoice:                begin                    ShouldTestQtyToShip := SalesLine."Shipment No." = '';                    OnTestSalesLineOnBeforeTestFieldQtyToShip(SalesLine, ShouldTestQtyToShip);                    if ShouldTestQtyToShip then                        SalesLine.TestField("Qty. to Ship", SalesLine.Quantity, ErrorInfo.Create());                    SalesLine.TestField("Return Qty. to Receive", 0, ErrorInfo.Create());                    SalesLine.TestField("Qty. to Invoice", SalesLine.Quantity, ErrorInfo.Create());                end;            SalesLine."Document Type"::"Return Order":                SalesLine.TestField("Qty. to Ship", 0, ErrorInfo.Create());            SalesLine."Document Type"::"Credit Memo":                begin                    ShouldTestReturnQty := SalesLine."Return Receipt No." = '';                    OnTestSalesLineOnAfterCalcShouldTestReturnQty(SalesLine, ShouldTestReturnQty);                    if ShouldTestReturnQty then                        SalesLine.TestField("Return Qty. to Receive", SalesLine.Quantity, ErrorInfo.Create());                    SalesLine.TestField("Qty. to Ship", 0, ErrorInfo.Create());                    SalesLine.TestField("Qty. to Invoice", SalesLine.Quantity, ErrorInfo.Create());                end;        end;    end;    local procedure CheckBlockedPostingGroups(SalesLine: Record "Sales Line")    var        GeneralPostingSetup: Record "General Posting Setup";        VATPostingSetup: Record "VAT Posting Setup";        ForwardLinkMgt: Codeunit "Forward Link Mgt.";    begin        if not SalesLine.HasTypeToFillMandatoryFields() then            exit;        if GeneralPostingSetup.Get(SalesLine."Gen. Bus. Posting Group", SalesLine."Gen. Prod. Posting Group") then            if GeneralPostingSetup.Blocked then                ErrorMessageMgt.LogContextFieldError(                SalesLine.FieldNo("Gen. Prod. Posting Group"),                StrSubstNo(                    SetupBlockedErr, GeneralPostingSetup.TableCaption(),                    GeneralPostingSetup.FieldCaption("Gen. Bus. Posting Group"), GeneralPostingSetup."Gen. Bus. Posting Group",                    GeneralPostingSetup.FieldCaption("Gen. Prod. Posting Group"), GeneralPostingSetup."Gen. Prod. Posting Group"),                GeneralPostingSetup.RecordId(), GeneralPostingSetup.FieldNo(Blocked),                ForwardLinkMgt.GetHelpCodeForFinancePostingGroups());        if VATPostingSetup.Get(SalesLine."VAT Bus. Posting Group", SalesLine."VAT Prod. Posting Group") then            if VATPostingSetup.Blocked then                ErrorMessageMgt.LogContextFieldError(                    SalesLine.FieldNo("VAT Prod. Posting Group"),                    StrSubstNo(                        SetupBlockedErr, VATPostingSetup.TableCaption(),                        VATPostingSetup.FieldCaption("VAT Bus. Posting Group"), VATPostingSetup."VAT Bus. Posting Group",                        VATPostingSetup.FieldCaption("VAT Prod. Posting Group"), VATPostingSetup."VAT Prod. Posting Group"),                    VATPostingSetup.RecordId(), VATPostingSetup.FieldNo(Blocked),                    ForwardLinkMgt.GetHelpCodeForFinanceSetupVAT());    end;    local procedure CheckItemTrackingQuantity(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header")    var        TrackingSpecification: Record "Tracking Specification";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckItemTrackingQuantity(SalesLine, IsHandled, SalesHeader);        if IsHandled then            exit;        SyncSurPlusItemTracking(SalesHeader, SalesLine);        case SalesHeader."Document Type" of            SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice:                TrackingSpecification.CheckItemTrackingQuantity(DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.", SalesLine."Qty. to Ship (Base)", SalesLine."Qty. to Invoice (Base)", SalesHeader.Ship, SalesHeader.Invoice);            SalesHeader."Document Type"::"Credit Memo", SalesHeader."Document Type"::"Return Order":                TrackingSpecification.CheckItemTrackingQuantity(DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.", SalesLine."Return Qty. to Receive (Base)", SalesLine."Qty. to Invoice (Base)", SalesHeader.Receive, SalesHeader.Invoice);            else                OnCheckItemTrackingQuantityOnDocumentTypeCaseElse(SalesHeader, SalesLine);        end;    end;    local procedure TestSalesLineItemCharge(SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestSalesLineItemCharge(SalesLine, IsHandled);        if IsHandled then            exit;        if (SalesLine.Amount = 0) and (SalesLine.Quantity <> 0) then            Error(ItemChargeZeroAmountErr, SalesLine."No.");        SalesLine.TestField("Job No.", '', ErrorInfo.Create());        SalesLine.TestField("Job Contract Entry No.", 0, ErrorInfo.Create());    end;    local procedure TestSalesLineFixedAsset(SalesLine: Record "Sales Line")    var        FixedAsset: Record "Fixed Asset";        DeprBook: Record "Depreciation Book";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestSalesLineFixedAsset(SalesLine, IsHandled);        if IsHandled then            exit;        SalesLine.TestField("Job No.", '', ErrorInfo.Create());        SalesLine.TestField("Depreciation Book Code", ErrorInfo.Create());        DeprBook.Get(SalesLine."Depreciation Book Code");        DeprBook.TestField("G/L Integration - Disposal", true, ErrorInfo.Create());        FixedAsset.Get(SalesLine."No.");        FixedAsset.TestField("Budgeted Asset", false, ErrorInfo.Create());    end;    local procedure TestSalesLineJob(SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestSalesLineJob(SalesLine, IsHandled);        if IsHandled then            exit;        if not (SalesLine."Document Type" in [SalesLine."Document Type"::Invoice, SalesLine."Document Type"::"Credit Memo"]) then            SalesLine.TestField("Job No.", '', ErrorInfo.Create());    end;    local procedure TestSalesLineOthers(SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestSalesLineOthers(SalesLine, IsHandled);        if IsHandled then            exit;        SalesLine.TestField("Depreciation Book Code", '', ErrorInfo.Create());        SalesLine.TestField("Depr. until FA Posting Date", false, ErrorInfo.Create());        SalesLine.TestField("FA Posting Date", 0D, ErrorInfo.Create());        SalesLine.TestField("Duplicate in Depreciation Book", '', ErrorInfo.Create());        SalesLine.TestField("Use Duplication List", false, ErrorInfo.Create());    end;    local procedure TestUpdatedSalesLine(SalesLine: Record "Sales Line")    var        ForwardLinkMgt: Codeunit "Forward Link Mgt.";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestUpdatedSalesLine(SalesLine, IsHandled, ErrorMessageMgt);        if IsHandled then            exit;        if SalesLine."Drop Shipment" then begin            if SalesLine.Type <> SalesLine.Type::Item then                SalesLine.TestField("Drop Shipment", false);            if (SalesLine."Qty. to Ship" <> 0) and (SalesLine."Purch. Order Line No." = 0) then                ErrorMessageMgt.LogErrorMessage(SalesLine.FieldNo("Purchasing Code"), StrSubstNo(DropShipmentErr, SalesLine."Line No."),                    0, 0, ForwardLinkMgt.GetHelpCodeForSalesLineDropShipmentErr());        end;        if SalesLine.Quantity = 0 then            SalesLine.TestField(Amount, 0)        else begin            SalesLine.TestField("No.");            SalesLine.TestField(Type);            if not ApplicationAreaMgmt.IsSalesTaxEnabled() then                TestGenPostingGroups(SalesLine);        end;    end;    local procedure TestGenPostingGroups(var SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestGenPostingGroups(SalesLine, IsHandled);        if IsHandled then            exit;        SalesLine.TestField("Gen. Bus. Posting Group");        SalesLine.TestField("Gen. Prod. Posting Group");    end;    local procedure UpdateReceiveAndCheckIfInvPutawayExists(var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateReceiveAndCheckIfInvPutawayExists(IsHandled, SalesHeader);        if IsHandled then            exit;        if SalesHeader.Receive then begin            SalesHeader.Receive := CheckTrackingAndWarehouseForReceive(SalesHeader);            if not InvtPickPutaway then                if CheckIfInvPutawayExists() then                    Error(ErrorInfo.Create(InvPutAwayExistsErr, true, SalesHeader));        end;    end;    local procedure UpdateShipAndCheckIfInvPickExists(var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnCheckAndUpdateOnBeforeCheckShip(IsHandled, SalesHeader);        if IsHandled then            exit;        if SalesHeader.Ship then begin            SalesHeader.Ship := CheckTrackingAndWarehouseForShip(SalesHeader);            if not InvtPickPutaway then                if CheckIfInvPickExists(SalesHeader) then                    Error(ErrorInfo.Create(InvPickExistsErr, true, SalesHeader));        end;    end;    local procedure UpdatePostingNos(var SalesHeader: Record "Sales Header") ModifyHeader: Boolean    begin        OnBeforeUpdatePostingNos(SalesHeader, SuppressCommit, ModifyHeader);        UpdateShippingNo(SalesHeader, ModifyHeader);        UpdateReturnReceiptNo(SalesHeader, ModifyHeader);        UpdatePostingNo(SalesHeader, ModifyHeader);        OnAfterUpdatePostingNos(SalesHeader, SuppressCommit);    end;    local procedure UpdateShippingNo(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean)    var        NoSeries: Codeunit "No. Series";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateShippingNo(SalesHeader, WhseShip, WhseReceive, InvtPickPutaway, PreviewMode, ModifyHeader, IsHandled);        UpdateShippingNoTelemetry(SalesHeader);        if IsHandled then            exit;        if SalesHeader.Ship and (SalesHeader."Shipping No." = '') then            if (SalesHeader."Document Type" = SalesHeader."Document Type"::Order) or               ((SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice) and SalesSetup."Shipment on Invoice")            then                if not PreviewMode then begin                    ResetPostingNoSeriesFromSetup(SalesHeader."Shipping No. Series", SalesSetup."Posted Shipment Nos.");                    SalesHeader.TestField("Shipping No. Series");                    SalesHeader."Shipping No." := NoSeries.GetNextNo(SalesHeader."Shipping No. Series", SalesHeader."Posting Date");                    ModifyHeader := true;                    if NoSeries.IsNoSeriesInDateOrder(SalesHeader."Shipping No. Series") then                        DateOrderSeriesUsed := true;                    // Check for posting conflicts.                    if SalesShptHeader.Get(SalesHeader."Shipping No.") then                        Error(SalesShptHeaderConflictErr, SalesHeader."Shipping No.");                end;        OnAfterUpdateShippingNo(SalesHeader, PreviewMode, ModifyHeader);    end;    local procedure UpdateShippingNoTelemetry(var SalesHeader: Record "Sales Header")    var        TelemetryCustomDimensions: Dictionary of [Text, Text];        PreviewTokenFoundLbl: Label 'Preview token %1 found on fields.', Locked = true;        PreviewToken: Text;    begin        if not Format(SalesHeader."Shipping No.").StartsWith(PostingPreviewNoTok) and           not Format(SalesHeader."Return Receipt No.").StartsWith(PostingPreviewNoTok) and           not Format(SalesHeader."Posting No.").StartsWith(PostingPreviewNoTok)        then            exit;        TelemetryCustomDimensions.Add(SalesHeader.FieldCaption(SystemId), SalesHeader.SystemId);        TelemetryCustomDimensions.Add(SalesHeader.FieldCaption("Document Type"), Format(SalesHeader."Document Type"));        if Format(SalesHeader."Shipping No.").StartsWith(PostingPreviewNoTok) then begin            PreviewToken := SalesHeader."Shipping No.";            TelemetryCustomDimensions.Add(SalesHeader.FieldCaption("Shipping No."), SalesHeader."Shipping No.");            SalesHeader."Shipping No." := '';        end;        if Format(SalesHeader."Return Receipt No.").StartsWith(PostingPreviewNoTok) then begin            PreviewToken := SalesHeader."Return Receipt No.";            TelemetryCustomDimensions.Add(SalesHeader.FieldCaption("Return Receipt No."), SalesHeader."Return Receipt No.");            SalesHeader."Return Receipt No." := '';        end;        if Format(SalesHeader."Posting No.").StartsWith(PostingPreviewNoTok) then begin            PreviewToken := SalesHeader."Posting No.";            TelemetryCustomDimensions.Add(SalesHeader.FieldCaption("Posting No."), SalesHeader."Posting No.");            SalesHeader."Posting No." := '';        end;        Session.LogMessage('0000CUV', StrSubstNo(PreviewTokenFoundLbl, PreviewToken), Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::All, TelemetryCustomDimensions);    end;    local procedure UpdatePostingNo(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean)    var        NoSeries: Codeunit "No. Series";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdatePostingNo(SalesHeader, PreviewMode, ModifyHeader, IsHandled, DateOrderSeriesUsed);        if IsHandled then            exit;        if SalesHeader.Invoice and (SalesHeader."Posting No." = '') then begin            if (SalesHeader."No. Series" <> '') or                (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"])            then begin                if SalesHeader."Document Type" in [SalesHeader."Document Type"::"Return Order"] then                    ResetPostingNoSeriesFromSetup(SalesHeader."Posting No. Series", SalesSetup."Posted Credit Memo Nos.")                else                    if (SalesHeader."Document Type" <> SalesHeader."Document Type"::"Credit Memo") then                        ResetPostingNoSeriesFromSetup(SalesHeader."Posting No. Series", SalesSetup."Posted Invoice Nos.");                if SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo" then                    if (SalesSetup."Posted Credit Memo Nos." <> '') and (SalesHeader."Posting No. Series" = '') then                        CheckDefaultNoSeries(SalesSetup."Posted Credit Memo Nos.");                SalesHeader.TestField("Posting No. Series");            end;            if (SalesHeader."No. Series" <> SalesHeader."Posting No. Series") or                (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"])            then                if not PreviewMode then begin                    SalesHeader."Posting No." := NoSeries.GetNextNo(SalesHeader."Posting No. Series", SalesHeader."Posting Date");                    if NoSeries.IsNoSeriesInDateOrder(SalesHeader."Posting No. Series") then                        DateOrderSeriesUsed := true;                    ModifyHeader := true;                end;            // Check for posting conflicts.            if not PreviewMode then                if SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice] then begin                    if SalesInvHeader.Get(SalesHeader."Posting No.") then                        Error(SalesInvHeaderConflictErr, SalesHeader."Posting No.");                end else                    if SalesCrMemoHeader.Get(SalesHeader."Posting No.") then                        Error(SalesCrMemoHeaderConflictErr, SalesHeader."Posting No.");        end;    end;    local procedure UpdateReturnReceiptNo(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean)    var        NoSeries: Codeunit "No. Series";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateReturnReceiptNo(SalesHeader, ModifyHeader, IsHandled, PreviewMode);        if IsHandled then            exit;        if SalesHeader.Receive and (SalesHeader."Return Receipt No." = '') then            if (SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order") or               ((SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo") and SalesSetup."Return Receipt on Credit Memo")            then                if not PreviewMode then begin                    ResetPostingNoSeriesFromSetup(SalesHeader."Return Receipt No. Series", SalesSetup."Posted Return Receipt Nos.");                    SalesHeader.TestField("Return Receipt No. Series");                    SalesHeader."Return Receipt No." := NoSeries.GetNextNo(SalesHeader."Return Receipt No. Series", SalesHeader."Posting Date");                    ModifyHeader := true;                    if NoSeries.IsNoSeriesInDateOrder(SalesHeader."Return Receipt No. Series") then                        DateOrderSeriesUsed := true;                    // Check for posting conflicts.                    if ReturnRcptHeader.Get(SalesHeader."Return Receipt No.") then                        Error(SalesReturnRcptHeaderConflictErr, SalesHeader."Return Receipt No.")                end;        OnAfterUpdateReturnReceiptNo(SalesHeader);    end;    local procedure ResetPostingNoSeriesFromSetup(var PostingNoSeries: Code[20]; SetupNoSeries: Code[20])    begin        if (PostingNoSeries = '') and (SetupNoSeries <> '') then            PostingNoSeries := SetupNoSeries;    end;    local procedure UpdateAssociatedPurchaseOrder(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; SalesHeader: Record "Sales Header")    var        PurchOrderHeader: Record "Purchase Header";        PurchOrderLine: Record "Purchase Line";        PurchLineReserve: Codeunit "Purch. Line-Reserve";    begin        TempDropShptPostBuffer.Reset();        if TempDropShptPostBuffer.IsEmpty() then            exit;        Clear(PurchOrderHeader);        TempDropShptPostBuffer.FindSet();        repeat            if PurchOrderHeader."No." <> TempDropShptPostBuffer."Order No." then begin                PurchOrderHeader.Get(PurchOrderHeader."Document Type"::Order, TempDropShptPostBuffer."Order No.");                CheckAndUpdateAssocOrderPostingDate(PurchOrderHeader, SalesHeader."Posting Date");                PurchOrderHeader."Last Receiving No." := PurchOrderHeader."Receiving No.";                PurchOrderHeader."Receiving No." := '';                PurchOrderHeader.Modify();                OnUpdateAssosOrderOnAfterPurchOrderHeaderModify(PurchOrderHeader);                PurchLineReserve.UpdateItemTrackingAfterPosting(PurchOrderHeader);            end;            PurchOrderLine.Get(              PurchOrderLine."Document Type"::Order,              TempDropShptPostBuffer."Order No.", TempDropShptPostBuffer."Order Line No.");            PurchOrderLine."Quantity Received" := PurchOrderLine."Quantity Received" + TempDropShptPostBuffer.Quantity;            PurchOrderLine."Qty. Received (Base)" := PurchOrderLine."Qty. Received (Base)" + TempDropShptPostBuffer."Quantity (Base)";            PurchOrderLine.InitOutstanding();            PurchOrderLine.ClearQtyIfBlank();            PurchOrderLine.InitQtyToReceive();            OnUpdateAssocOrderOnBeforeModifyPurchLine(PurchOrderLine, TempDropShptPostBuffer);            PurchOrderLine.Modify();            OnUpdateAssocOrderOnAfterModifyPurchLine(PurchOrderLine, TempDropShptPostBuffer);        until TempDropShptPostBuffer.Next() = 0;        TempDropShptPostBuffer.DeleteAll();    end;    /// <summary>    /// Removes the association between the sales line and the Purchase Line    /// </summary>    /// <param name="SalesOrderLine">The sales line for which the association is being removed.</param>    procedure UpdateAssocLines(var SalesOrderLine: Record "Sales Line")    var        PurchOrderLine: Record "Purchase Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateAssocLines(SalesOrderLine, IsHandled);        if IsHandled then            exit;        if not PurchOrderLine.Get(                PurchOrderLine."Document Type"::Order,                SalesOrderLine."Purchase Order No.", SalesOrderLine."Purch. Order Line No.")        then            exit;        PurchOrderLine."Sales Order No." := '';        PurchOrderLine."Sales Order Line No." := 0;        PurchOrderLine.Modify();        SalesOrderLine."Purchase Order No." := '';        SalesOrderLine."Purch. Order Line No." := 0;    end;    local procedure UpdateAssosOrderPostingNos(SalesHeader: Record "Sales Header") DropShipment: Boolean    var        TempSalesLine: Record "Sales Line" temporary;        PurchOrderHeader: Record "Purchase Header";        NoSeries: Codeunit "No. Series";        ReleasePurchaseDocument: Codeunit "Release Purchase Document";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateAssosOrderPostingNos(SalesHeader, TempSalesLineGlobal, PreviewMode, DropShipment, IsHandled);        if IsHandled then            exit(DropShipment);        ResetTempLines(TempSalesLine);        TempSalesLine.SetFilter("Purch. Order Line No.", '<>0');        OnUpdateAssosOrderPostingNosOnAfterSetFilterTempSalesLine(SalesHeader, TempSalesLine);        DropShipment := not TempSalesLine.IsEmpty();        TempSalesLine.SetFilter("Qty. to Ship", '<>0');        if DropShipment and SalesHeader.Ship then            if TempSalesLine.FindSet() then                repeat                    if PurchOrderHeader."No." <> TempSalesLine."Purchase Order No." then begin                        PurchOrderHeader.Get(PurchOrderHeader."Document Type"::Order, TempSalesLine."Purchase Order No.");                        PurchOrderHeader.TestField("Pay-to Vendor No.");                        PurchOrderHeader.Receive := true;                        OnUpdateAssosOrderPostingNosOnBeforeReleasePurchaseDocument(PurchOrderHeader, SalesHeader);                        ReleasePurchaseDocument.ReleasePurchaseHeader(PurchOrderHeader, PreviewMode);                        if PurchOrderHeader."Receiving No." = '' then begin                            PurchOrderHeader.TestField("Receiving No. Series");                            PurchOrderHeader."Receiving No." :=                              NoSeries.GetNextNo(PurchOrderHeader."Receiving No. Series", SalesHeader."Posting Date");                            OnUpdateAssosOrderPostingNosOnBeforeModifyPurchOrderHeader(PurchOrderHeader, SalesHeader);                            PurchOrderHeader.Modify();                        end;                        OnUpdateAssosOrderPostingNosOnAfterReleasePurchaseDocument(PurchOrderHeader, SalesHeader);                    end;                until TempSalesLine.Next() = 0;        OnAfterUpdateAssosOrderPostingNos(SalesHeader, TempSalesLine, DropShipment);        exit(DropShipment);    end;    local procedure CheckAndUpdateAssocOrderPostingDate(var PurchaseHeader: Record "Purchase Header"; PostingDate: Date)    var        PurchasesPayablesSetup: Record "Purchases & Payables Setup";        ReleasePurchaseDocument: Codeunit "Release Purchase Document";        OriginalDocumentDate: Date;    begin        if (PostingDate <> 0D) and (PurchaseHeader."Posting Date" <> PostingDate) then begin            ReleasePurchaseDocument.Reopen(PurchaseHeader);            ReleasePurchaseDocument.SetSkipCheckReleaseRestrictions();            OriginalDocumentDate := PurchaseHeader."Document Date";            PurchaseHeader.SetHideValidationDialog(true);            PurchaseHeader.Validate("Posting Date", PostingDate);            PurchasesPayablesSetup.SetLoadFields("Link Doc. Date To Posting Date");            PurchasesPayablesSetup.GetRecordOnce();            if PurchasesPayablesSetup."Link Doc. Date To Posting Date" then                PurchaseHeader.Validate("Document Date", PostingDate)            else                PurchaseHeader.Validate("Document Date", OriginalDocumentDate);            ReleasePurchaseDocument.Run(PurchaseHeader);        end;    end;    local procedure UpdateAfterPosting(SalesHeader: Record "Sales Header")    var        TempSalesLine: Record "Sales Line" temporary;    begin        ResetTempLines(TempSalesLine);        TempSalesLine.SetFilter("Qty. to Assemble to Order", '<>0');        if TempSalesLine.FindSet() then            repeat                FinalizePostATO(TempSalesLine);            until TempSalesLine.Next() = 0;        ResetTempLines(TempSalesLine);        TempSalesLine.SetFilter("Blanket Order Line No.", '<>0');        OnUpdateAfterPostingOnBeforeFindSetForUpdate(TempSalesLine, SalesHeader);        if TempSalesLine.FindSet() then            repeat                UpdateBlanketOrderLine(TempSalesLine, SalesHeader.Ship, SalesHeader.Receive, SalesHeader.Invoice);            until TempSalesLine.Next() = 0;        OnAfterUpdateAfterPosting(SalesHeader, TempSalesLine);    end;    local procedure UpdateLastPostingNos(var SalesHeader: Record "Sales Header")    begin        if SalesHeader.Ship then begin            SalesHeader."Last Shipping No." := SalesHeader."Shipping No.";            SalesHeader."Shipping No." := '';        end;        if SalesHeader.Invoice then begin            SalesHeader."Last Posting No." := SalesHeader."Posting No.";            SalesHeader."Posting No." := '';        end;        if SalesHeader.Receive then begin            SalesHeader."Last Return Receipt No." := SalesHeader."Return Receipt No.";            SalesHeader."Return Receipt No." := '';        end;        OnAfterUpdateLastPostingNos(SalesHeader);    end;    local procedure UpdateSalesLineBeforePost(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        OnBeforeUpdateSalesLineBeforePost(SalesLine, SalesHeader, WhseShip, WhseReceive, RoundingLineInserted, SuppressCommit);        if not (SalesHeader.Ship or RoundingLineInserted) then begin            SalesLine."Qty. to Ship" := 0;            SalesLine."Qty. to Ship (Base)" := 0;        end;        if not (SalesHeader.Receive or RoundingLineInserted) then begin            SalesLine."Return Qty. to Receive" := 0;            SalesLine."Return Qty. to Receive (Base)" := 0;        end;        JobContractLine := false;        if (SalesLine.Type = SalesLine.Type::Item) or (SalesLine.Type = SalesLine.Type::"G/L Account") or (SalesLine.Type = SalesLine.Type::" ") then            if SalesLine."Job Contract Entry No." > 0 then                PostJobContractLine(SalesHeader, SalesLine);        OnUpdateSalesLineBeforePostOnAfterPostJobContractLine(SalesInvHeader, SalesCrMemoHeader, SalesHeader, SalesLine);        if SalesLine.Type = SalesLine.Type::Resource then            JobTaskSalesLine := SalesLine;        if (SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice) and (SalesLine."Shipment No." <> '') then begin            SalesLine."Quantity Shipped" := SalesLine.Quantity;            SalesLine."Qty. Shipped (Base)" := SalesLine."Quantity (Base)";            SalesLine."Qty. to Ship" := 0;            SalesLine."Qty. to Ship (Base)" := 0;        end;        if (SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo") and (SalesLine."Return Receipt No." <> '') then begin            SalesLine."Return Qty. Received" := SalesLine.Quantity;            SalesLine."Return Qty. Received (Base)" := SalesLine."Quantity (Base)";            SalesLine."Return Qty. to Receive" := 0;            SalesLine."Return Qty. to Receive (Base)" := 0;        end;        InitSalesLineQtyToInvoice(SalesHeader, SalesLine);        IsHandled := false;        OnUpdateSalesLineBeforePostOnBeforeGetUnitCost(SalesLine, IsHandled);        if not IsHandled then            if (SalesLine.Type = SalesLine.Type::Item) and (SalesLine."No." <> '') then begin                SalesLine.GetItem(Item);                if (Item."Costing Method" = Item."Costing Method"::Standard) and not SalesLine.IsShipment() and not IsCreatedFromJob(SalesLine) then                    SalesLine.GetUnitCost();            end;        OnAfterUpdateSalesLineBeforePost(SalesLine, SalesHeader, WhseShip, WhseReceive, SuppressCommit);    end;    local procedure IsCreatedFromJob(var SalesLine: Record "Sales Line"): Boolean    begin        if (SalesLine."Job No." <> '') and (SalesLine."Job Task No." <> '') and (SalesLine."Job Contract Entry No." <> 0) then            exit(true);    end;    local procedure InitSalesLineQtyToInvoice(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInitSalesLineQtyToInvoice(SalesHeader, SalesLine, IsHandled);        if IsHandled then            exit;        if SalesHeader.Invoice then begin            if Abs(SalesLine."Qty. to Invoice") > Abs(SalesLine.MaxQtyToInvoice()) then                SalesLine.InitQtyToInvoice();        end else begin            SalesLine."Qty. to Invoice" := 0;            SalesLine."Qty. to Invoice (Base)" := 0;        end;    end;    local procedure UpdateWhseDocuments(SalesHeader: Record "Sales Header"; EverythingInvoiced: Boolean)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateWhseDocuments(SalesHeader, IsHandled, WhseReceive, WhseShip, WhseRcptHeader, WhseShptHeader, TempWhseRcptHeader, TempWhseShptHeader);        if IsHandled then            exit;        if WhseReceive then begin            WhsePostRcpt.PostUpdateWhseDocuments(WhseRcptHeader);            TempWhseRcptHeader.Delete();        end;        if WhseShip then begin            WhsePostShpt.PostUpdateWhseDocuments(WhseShptHeader);            TempWhseShptHeader.Delete();        end;        OnAfterUpdateWhseDocuments(SalesHeader, WhseShip, WhseReceive, WhseShptHeader, WhseRcptHeader, EverythingInvoiced);    end;    /// <summary>    /// Deletes the document, lines and records related to the sales header after posting, unless the SkipDelete parameter is set.    /// This is only run if everything was invoiced and the posting is not in PreviewMode    /// </summary>    /// <param name="SalesHeader">The sales header of the document that was posted.</param>    /// <param name="EverythingInvoiced">A flag indicating whether everything was invoiced. Only used in events, serves no functional purpose.</param>    procedure DeleteAfterPosting(var SalesHeader: Record "Sales Header"; EverythingInvoiced: Boolean)    var        SalesCommentLine: Record "Sales Comment Line";        SalesLine: Record "Sales Line";        TempSalesLine: Record "Sales Line" temporary;        WarehouseRequest: Record "Warehouse Request";        IsHandled: Boolean;        SkipDelete: Boolean;    begin        OnBeforeDeleteAfterPosting(SalesHeader, SalesInvHeader, SalesCrMemoHeader, SkipDelete, SuppressCommit, EverythingInvoiced, TempSalesLineGlobal);        if SkipDelete then            exit;        IsHandled := false;        OnDeleteAfterPostingOnBeforeDeleteLinks(SalesHeader, IsHandled);        if not IsHandled then            if SalesHeader.HasLinks() then                SalesHeader.DeleteLinks();        WarehouseRequest.DeleteRequest(DATABASE::"Sales Line", SalesHeader."Document Type".AsInteger(), SalesHeader."No.");        OnDeleteAfterPostingOnBeforeDeleteSalesHeader(SalesHeader);        SalesHeader.Delete();        SalesLineReserve.DeleteInvoiceSpecFromHeader(SalesHeader);        DeleteATOLinks(SalesHeader);        ResetTempLines(TempSalesLine);        OnDeleteAfterPostingOnAfterSetupSalesHeader(SalesHeader, TempSalesLine);        if TempSalesLine.FindFirst() then            repeat                if TempSalesLine."Deferral Code" <> '' then                    DeferralUtilities.RemoveOrSetDeferralSchedule(                        '', Enum::"Deferral Document Type"::Sales.AsInteger(), '', '', TempSalesLine."Document Type".AsInteger(),                        TempSalesLine."Document No.", TempSalesLine."Line No.", 0, 0D, TempSalesLine.Description, '', true);                if TempSalesLine.HasLinks() then                    TempSalesLine.DeleteLinks();                OnDeleteAfterPostingOnAfterDeleteLinks(TempSalesLine);            until TempSalesLine.Next() = 0;        SalesLine.SetCurrentKey("Document Type", "Document No.", "Line No.");        SalesLine.SetRange("Document Type", SalesHeader."Document Type");        SalesLine.SetRange("Document No.", SalesHeader."No.");        OnBeforeSalesLineDeleteAll(SalesLine, SuppressCommit, SalesHeader);        SalesLine.DeleteAll();        OnDeleteAfterPostingOnAfterSalesLineDeleteAll(SalesHeader, SalesInvHeader, SalesCrMemoHeader, SuppressCommit, EverythingInvoiced);        DeleteItemChargeAssgnt(SalesHeader);        SalesCommentLine.DeleteComments(SalesHeader."Document Type".AsInteger(), SalesHeader."No.");        OnAfterDeleteAfterPosting(SalesHeader, SalesInvHeader, SalesCrMemoHeader, SuppressCommit);    end;    local procedure FinalizePosting(var SalesHeader: Record "Sales Header"; EverythingInvoiced: Boolean; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    var        CRMConnectionSetup: Record "CRM Connection Setup";        TempSalesLine: Record "Sales Line" temporary;        GenJnlPostPreview: Codeunit "Gen. Jnl.-Post Preview";        ICInboxOutboxMgt: Codeunit ICInboxOutboxMgt;        WhseSalesRelease: Codeunit "Whse.-Sales Release";        ArchiveManagement: Codeunit ArchiveManagement;        IsHandled: Boolean;    begin        OnBeforeFinalizePosting(SalesHeader, TempSalesLineGlobal, EverythingInvoiced, SuppressCommit, GenJnlPostLine);        if (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"]) and            (not EverythingInvoiced)        then begin            SalesHeader.Modify();            InsertTrackingSpecification(SalesHeader);            PostUpdateOrderLine(SalesHeader);            UpdateAssociatedPurchaseOrder(TempDropShptPostBuffer, SalesHeader);            if not PreviewMode then                UpdateWhseDocuments(SalesHeader, EverythingInvoiced);            WhseSalesRelease.Release(SalesHeader);            UpdateItemChargeAssgnt(SalesHeader);            OnFinalizePostingOnAfterUpdateItemChargeAssgnt(SalesHeader, TempDropShptPostBuffer, GenJnlPostLine);        end else begin            OnFinalizePostingOnBeforeInsertTrackingSpecification(TempDropShptPostBuffer, TempItemChargeAssgntSales, SalesHeader, TempTrackingSpecification, EverythingInvoiced, TempSalesLine, TempSalesLineGlobal, this);            case SalesHeader."Document Type" of                SalesHeader."Document Type"::Invoice:                    begin                        PostUpdateInvoiceLine(SalesHeader);                        InsertTrackingSpecification(SalesHeader);                        PostUpdateOrderNo(SalesInvHeader);                        ArchiveRelatedJob(SalesHeader);                    end;                SalesHeader."Document Type"::"Credit Memo":                    begin                        PostUpdateReturnReceiptLine();                        InsertTrackingSpecification(SalesHeader);                        PostUpdateOrderNo(SalesCrMemoHeader);                    end;                else begin                    UpdateAssociatedPurchaseOrder(TempDropShptPostBuffer, SalesHeader);                    if DropShipOrder then                        InsertTrackingSpecification(SalesHeader);                    ResetTempLines(TempSalesLine);                    TempSalesLine.SetFilter("Purch. Order Line No.", '<>0');                    if TempSalesLine.FindSet() then                        repeat                            UpdateAssocLines(TempSalesLine);                            TempSalesLine.Modify();                        until TempSalesLine.Next() = 0;                    ResetTempLines(TempSalesLine);                    TempSalesLine.SetFilter("Prepayment %", '<>0');                    if TempSalesLine.FindSet() then                        repeat                            DecrementPrepmtAmtInvLCY(                                SalesHeader, TempSalesLine, TempSalesLine."Prepmt. Amount Inv. (LCY)", TempSalesLine."Prepmt. VAT Amount Inv. (LCY)");                            TempSalesLine.Modify();                        until TempSalesLine.Next() = 0;                    if (SalesHeader."Document Type" = SalesHeader."Document Type"::Order) and SalesSetup."Archive Orders" then begin                        PostUpdateOrderLine(SalesHeader);                        if (not OrderArchived) or (OrderArchived and CRMConnectionSetup.IsBidirectionalSalesOrderIntEnabled()) then begin                            ArchiveManagement.AutoArchiveSalesDocument(SalesHeader);                            OrderArchived := true;                        end;                    end;                end;            end;            UpdateAfterPosting(SalesHeader);            UpdateEmailParameters(SalesHeader);            if not PreviewMode then                UpdateWhseDocuments(SalesHeader, EverythingInvoiced);            if not OrderArchived then begin                ArchiveManagement.AutoArchiveSalesDocument(SalesHeader);                OrderArchived := true;            end;            OnFinalizePostingOnBeforeDeleteApprovalEntries(SalesHeader, EverythingInvoiced);            DeleteApprovalEntries(SalesHeader);            if not PreviewMode then                DeleteAfterPosting(SalesHeader, EverythingInvoiced);        end;        InsertValueEntryRelation();        OnAfterFinalizePostingOnBeforeCommit(          SalesHeader, SalesShptHeader, SalesInvHeader, SalesCrMemoHeader, ReturnRcptHeader, GenJnlPostLine,          SuppressCommit, PreviewMode, WhseShip, WhseReceive, EverythingInvoiced);        if PreviewMode and (CalledBy = 0) then begin            if GuiAllowed() and not HideProgressWindow then                Window.Close();            IsHandled := false;            OnFinalizePostingOnBeforeGenJnlPostPreviewThrowError(SalesHeader, SalesInvHeader, SalesCrMemoHeader, IsHandled);            if not IsHandled then                GenJnlPostPreview.ThrowError();        end;        ICInboxOutboxMgt.CheckPermissionToSendICTransaction(SalesHeader);        if not (InvtPickPutaway or SuppressCommit or PreviewMode) then            Commit();        if GuiAllowed() and not HideProgressWindow then            Window.Close();        IsHandled := false;        OnFinalizePostingOnBeforeCreateOutboxSalesTrans(SalesHeader, IsHandled, EverythingInvoiced, SalesInvHeader, SalesCrMemoHeader);        if not IsHandled then            if SalesHeader.Invoice and SalesHeader."Send IC Document" then                if SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice] then                    ICInboxOutboxMgt.CreateOutboxSalesInvTrans(SalesInvHeader)                else                    ICInboxOutboxMgt.CreateOutboxSalesCrMemoTrans(SalesCrMemoHeader);        OnAfterFinalizePosting(          SalesHeader, SalesShptHeader, SalesInvHeader, SalesCrMemoHeader, ReturnRcptHeader,          GenJnlPostLine, SuppressCommit, PreviewMode);        ClearPostBuffers();        if SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order" then            UpdateSalesOrderLineIfExist(SalesHeader."No.");    end;    local procedure DeleteApprovalEntries(var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeDeleteApprovalEntries(SalesHeader, IsHandled);        if IsHandled then            exit;        ApprovalsMgmt.DeleteApprovalEntries(SalesHeader.RecordId());        OnAfterDeleteApprovalEntries(SalesHeader, SalesInvHeader, SalesCrMemoHeader, SalesShptHeader, ReturnRcptHeader);    end;    /// <summary>    /// Initializes the global Currency variable with the currency code passed as a parameter.    /// </summary>    /// <param name="CurrencyCode">The currency code to initialize the global Currency variable with.</param>    procedure GetCurrency(CurrencyCode: Code[10])    begin        Currency.Initialize(CurrencyCode, true);        OnAfterGetCurrency(CurrencyCode, Currency);    end;    local procedure DivideAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; SalesLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary)    begin        DivideAmount(SalesHeader, SalesLine, QtyType, SalesLineQty, TempVATAmountLine, TempVATAmountLineRemainder, true);    end;    local procedure DivideAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; SalesLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; IncludePrepayments: Boolean)    var        OriginalDeferralAmount: Decimal;        IsHandled: Boolean;    begin        if RoundingLineInserted and (RoundingLineNo = SalesLine."Line No.") then            exit;        IsHandled := false;        OnBeforeDivideAmount(            SalesHeader, SalesLine, QtyType, SalesLineQty, TempVATAmountLine, TempVATAmountLineRemainder, IsHandled, TempPrepmtDeductLCYSalesLine);        if IsHandled then            exit;        if (SalesLineQty = 0) or (SalesLine."Unit Price" = 0) then begin            SalesLine."Line Amount" := 0;            SalesLine."Line Discount Amount" := 0;            SalesLine."Inv. Discount Amount" := 0;            SalesLine."VAT Base Amount" := 0;            SalesLine.Amount := 0;            SalesLine."Amount Including VAT" := 0;            OnDivideAmountOnAfterInitAmount(SalesHeader, SalesLine, SalesLineQty);        end else begin            OriginalDeferralAmount := SalesLine.GetDeferralAmount();            IsHandled := false;            OnDivideAmountOnBeforeTempVATAmountLineGet(SalesLine, TempVATAmountLine, IsHandled);            if not IsHandled then                TempVATAmountLine.Get(SalesLine."VAT Identifier", SalesLine."VAT Calculation Type", SalesLine."Tax Group Code", false, SalesLine."Line Amount" >= 0);            if SalesLine."VAT Calculation Type" = SalesLine."VAT Calculation Type"::"Sales Tax" then                SalesLine."VAT %" := TempVATAmountLine."VAT %";            TempVATAmountLineRemainder := TempVATAmountLine;            if not TempVATAmountLineRemainder.Find() then begin                TempVATAmountLineRemainder.Init();                TempVATAmountLineRemainder.Insert();            end;            DivideAmountInitLineAmountAndLineDiscountAmount(SalesHeader, SalesLine, SalesLineQty, IncludePrepayments, TempVATAmountLine);            OnDivideAmountOnAfterInitLineDiscountAmount(SalesHeader, SalesLine, SalesLineQty);            if SalesLine."Allow Invoice Disc." and (TempVATAmountLine."Inv. Disc. Base Amount" <> 0) then                if QtyType = QtyType::Invoicing then                    SalesLine."Inv. Discount Amount" := SalesLine."Inv. Disc. Amount to Invoice"                else begin                    TempVATAmountLineRemainder."Invoice Discount Amount" :=                      TempVATAmountLineRemainder."Invoice Discount Amount" +                      TempVATAmountLine."Invoice Discount Amount" * SalesLine."Line Amount" /                      TempVATAmountLine."Inv. Disc. Base Amount";                    SalesLine."Inv. Discount Amount" :=                      Round(                        TempVATAmountLineRemainder."Invoice Discount Amount", Currency."Amount Rounding Precision");                    TempVATAmountLineRemainder."Invoice Discount Amount" :=                      TempVATAmountLineRemainder."Invoice Discount Amount" - SalesLine."Inv. Discount Amount";                end;            IsHandled := false;            OnDivideAmountOnBeforeUpdateTempVATAmountLineRemainder(SalesLine, SalesHeader, TempVATAmountLine, TempVATAmountLineRemainder, Currency, IsHandled);            if not IsHandled then                if SalesHeader."Prices Including VAT" then begin                    if (TempVATAmountLine.CalcLineAmount() = 0) or (SalesLine."Line Amount" = 0) then begin                        TempVATAmountLineRemainder."VAT Amount" := 0;                        TempVATAmountLineRemainder."Amount Including VAT" := 0;                    end else begin                        TempVATAmountLineRemainder."VAT Amount" +=                            TempVATAmountLine."VAT Amount" * SalesLine.CalcLineAmount() / TempVATAmountLine.CalcLineAmount();                        TempVATAmountLineRemainder."Amount Including VAT" +=                            TempVATAmountLine."Amount Including VAT" * SalesLine.CalcLineAmount() / TempVATAmountLine.CalcLineAmount();                    end;                    if SalesLine."Line Discount %" <> 100 then                        SalesLine."Amount Including VAT" :=                            Round(TempVATAmountLineRemainder."Amount Including VAT", Currency."Amount Rounding Precision")                    else                        SalesLine."Amount Including VAT" := 0;                    SalesLine.Amount :=                        Round(SalesLine."Amount Including VAT", Currency."Amount Rounding Precision") -                        Round(TempVATAmountLineRemainder."VAT Amount", Currency."Amount Rounding Precision");                    CalcVATBaseAmount(SalesHeader, SalesLine, TempVATAmountLine, TempVATAmountLineRemainder);                    TempVATAmountLineRemainder."Amount Including VAT" :=                        TempVATAmountLineRemainder."Amount Including VAT" - SalesLine."Amount Including VAT";                    TempVATAmountLineRemainder."VAT Amount" :=                        TempVATAmountLineRemainder."VAT Amount" - SalesLine."Amount Including VAT" + SalesLine.Amount;                end else                    if SalesLine."VAT Calculation Type" = SalesLine."VAT Calculation Type"::"Full VAT" then begin                        if SalesLine."Line Discount %" <> 100 then                            SalesLine."Amount Including VAT" := SalesLine.CalcLineAmount()                        else                            SalesLine."Amount Including VAT" := 0;                        SalesLine.Amount := 0;                        SalesLine."VAT Base Amount" := 0;                    end else begin                        SalesLine.Amount := SalesLine.CalcLineAmount();                        CalcVATBaseAmount(SalesHeader, SalesLine, TempVATAmountLine, TempVATAmountLineRemainder);                        if TempVATAmountLine."VAT Base" = 0 then                            TempVATAmountLineRemainder."VAT Amount" := 0                        else                            TempVATAmountLineRemainder."VAT Amount" +=                                TempVATAmountLine."VAT Amount" * SalesLine.CalcLineAmount() / TempVATAmountLine.CalcLineAmount();                        if SalesLine."Line Discount %" <> 100 then                            SalesLine."Amount Including VAT" :=                                SalesLine.Amount + Round(TempVATAmountLineRemainder."VAT Amount", Currency."Amount Rounding Precision")                        else                            SalesLine."Amount Including VAT" := 0;                        TempVATAmountLineRemainder."VAT Amount" :=                            TempVATAmountLineRemainder."VAT Amount" - SalesLine."Amount Including VAT" + SalesLine.Amount;                    end;            OnDivideAmountOnBeforeTempVATAmountLineRemainderModify(SalesHeader, SalesLine, TempVATAmountLine, TempVATAmountLineRemainder, Currency);            TempVATAmountLineRemainder.Modify();#pragma warning disable AA0005            if SalesLine."Deferral Code" <> '' then begin                GetInvoicePostingSetup();                InvoicePostingInterface.CalcDeferralAmounts(SalesHeader, SalesLine, OriginalDeferralAmount);            end;#pragma warning restore AA0005        end;        OnAfterDivideAmount(SalesHeader, SalesLine, QtyType, SalesLineQty, TempVATAmountLine, TempVATAmountLineRemainder);    end;    local procedure DivideAmountInitLineAmountAndLineDiscountAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal; IncludePrepayments: Boolean; var TempVATAmountLine: Record "VAT Amount Line" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeDivideAmountInitLineAmountAndLineDiscountAmount(SalesHeader, SalesLine, SalesLineQty, IncludePrepayments, IsHandled, TempPrepmtDeductLCYSalesLine, TempVATAmountLine);        if IsHandled then            exit;        if IncludePrepayments then            SalesLine."Line Amount" := SalesLine.GetLineAmountToHandleInclPrepmt(SalesLineQty) + GetPrepmtDiffToLineAmount(SalesLine)        else            SalesLine."Line Amount" := SalesLine.GetLineAmountToHandle(SalesLineQty);        if SalesLineQty <> SalesLine.Quantity then            SalesLine."Line Discount Amount" :=                Round(SalesLine."Line Discount Amount" * SalesLineQty / SalesLine.Quantity, Currency."Amount Rounding Precision");    end;    local procedure RoundAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal)    var        NoVAT: Boolean;        IsHandled: Boolean;    begin        OnBeforeRoundAmount(SalesHeader, SalesLine, SalesLineQty, CurrExchRate);        IncrAmount(SalesHeader, SalesLine, TotalSalesLine);        TotalSalesLine."Net Weight" += Round(SalesLineQty * SalesLine."Net Weight", UOMMgt.WeightRndPrecision());        TotalSalesLine."Gross Weight" += Round(SalesLineQty * SalesLine."Gross Weight", UOMMgt.WeightRndPrecision());        TotalSalesLine."Unit Volume" += Round(SalesLineQty * SalesLine."Unit Volume", UOMMgt.CubageRndPrecision());        TotalSalesLine.Quantity += SalesLineQty;        if SalesLine."Units per Parcel" > 0 then            TotalSalesLine."Units per Parcel" += Round(SalesLineQty / SalesLine."Units per Parcel", 1, '>');        xSalesLine := SalesLine;        SalesLineACY := SalesLine;        IsHandled := false;        OnRoundAmountOnAfterAssignSalesLines(xSalesLine, SalesLineACY, SalesHeader, IsHandled, TotalSalesLine, TotalSalesLineLCY, SalesLine);        if not IsHandled then            if (SalesHeader."Currency Code" <> '') and (SalesLine.Type <> SalesLine.Type::" ") then begin                NoVAT := SalesLine.Amount = SalesLine."Amount Including VAT";                SalesLine."Amount Including VAT" :=                  Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      SalesHeader.GetUseDate(), SalesHeader."Currency Code",                      TotalSalesLine."Amount Including VAT", SalesHeader."Currency Factor")) -                  TotalSalesLineLCY."Amount Including VAT";                if NoVAT then                    SalesLine.Amount := SalesLine."Amount Including VAT"                else                    SalesLine.Amount :=                      Round(                        CurrExchRate.ExchangeAmtFCYToLCY(                          SalesHeader.GetUseDate(), SalesHeader."Currency Code",                          TotalSalesLine.Amount, SalesHeader."Currency Factor")) -                      TotalSalesLineLCY.Amount;                SalesLine."Line Amount" :=                  Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      SalesHeader.GetUseDate(), SalesHeader."Currency Code",                      TotalSalesLine."Line Amount", SalesHeader."Currency Factor")) -                  TotalSalesLineLCY."Line Amount";                SalesLine."Line Discount Amount" :=                  Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      SalesHeader.GetUseDate(), SalesHeader."Currency Code",                      TotalSalesLine."Line Discount Amount", SalesHeader."Currency Factor")) -                  TotalSalesLineLCY."Line Discount Amount";                SalesLine."Inv. Discount Amount" :=                  Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      SalesHeader.GetUseDate(), SalesHeader."Currency Code",                      TotalSalesLine."Inv. Discount Amount", SalesHeader."Currency Factor")) -                  TotalSalesLineLCY."Inv. Discount Amount";                SalesLine."VAT Difference" :=                  Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      SalesHeader.GetUseDate(), SalesHeader."Currency Code",                      TotalSalesLine."VAT Difference", SalesHeader."Currency Factor")) -                  TotalSalesLineLCY."VAT Difference";                SalesLine."VAT Base Amount" :=                  Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      SalesHeader.GetUseDate(), SalesHeader."Currency Code",                      TotalSalesLine."VAT Base Amount", SalesHeader."Currency Factor")) -                  TotalSalesLineLCY."VAT Base Amount";            end;        IsHandled := false;        OnRoundAmountOnBeforeIncrAmount(SalesHeader, SalesLine, SalesLineQty, TotalSalesLine, TotalSalesLineLCY, xSalesLine, IsHandled);        if not IsHandled then begin            IncrAmount(SalesHeader, SalesLine, TotalSalesLineLCY);            TotalSalesLineLCY."Unit Cost (LCY)" += Round(SalesLineQty * SalesLine."Unit Cost (LCY)");        end;        OnAfterRoundAmount(SalesHeader, SalesLine, SalesLineQty);    end;    /// <summary>    /// Reverses the amounts and quantities of a sales line.    /// </summary>    /// <param name="SalesLine">The sales line for which to reverse the amounts and quantities.</param>    procedure ReverseAmount(var SalesLine: Record "Sales Line")    begin        SalesLine."Qty. to Ship" := -SalesLine."Qty. to Ship";        SalesLine."Qty. to Ship (Base)" := -SalesLine."Qty. to Ship (Base)";        SalesLine."Return Qty. to Receive" := -SalesLine."Return Qty. to Receive";        SalesLine."Return Qty. to Receive (Base)" := -SalesLine."Return Qty. to Receive (Base)";        SalesLine."Qty. to Invoice" := -SalesLine."Qty. to Invoice";        SalesLine."Qty. to Invoice (Base)" := -SalesLine."Qty. to Invoice (Base)";        SalesLine."Line Amount" := -SalesLine."Line Amount";        SalesLine.Amount := -SalesLine.Amount;        SalesLine."VAT Base Amount" := -SalesLine."VAT Base Amount";        SalesLine."VAT Difference" := -SalesLine."VAT Difference";        SalesLine."Amount Including VAT" := -SalesLine."Amount Including VAT";        SalesLine."Line Discount Amount" := -SalesLine."Line Discount Amount";        SalesLine."Inv. Discount Amount" := -SalesLine."Inv. Discount Amount";        OnAfterReverseAmount(SalesLine);    end;    local procedure InvoiceRounding(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; UseTempData: Boolean; BiggestLineNo: Integer)    var        CustPostingGr: Record "Customer Posting Group";        InvoiceRoundingAmount: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInvoiceRounding(SalesHeader, IsHandled);        if IsHandled then            exit;        Currency.TestField("Invoice Rounding Precision");        InvoiceRoundingAmount :=          -Round(            TotalSalesLine."Amount Including VAT" -            Round(              TotalSalesLine."Amount Including VAT", Currency."Invoice Rounding Precision", Currency.InvoiceRoundingDirection()),            Currency."Amount Rounding Precision");        OnBeforeInvoiceRoundingAmount(          SalesHeader, TotalSalesLine."Amount Including VAT", UseTempData, InvoiceRoundingAmount, SuppressCommit, TotalSalesLine, Currency);        if InvoiceRoundingAmount <> 0 then begin            CustPostingGr.Get(SalesHeader."Customer Posting Group");            SalesLine.Init();            BiggestLineNo := BiggestLineNo + 10000;            SalesLine."System-Created Entry" := true;            if UseTempData then begin                SalesLine."Line No." := 0;                SalesLine.Type := SalesLine.Type::"G/L Account";                SalesLine.SetHideValidationDialog(true);            end else begin                SalesLine."Line No." := BiggestLineNo;                SalesLine.Validate(Type, SalesLine.Type::"G/L Account");            end;            SalesLine.Validate("No.", CustPostingGr.GetInvRoundingAccount());            SalesLine.Validate(Quantity, 1);            OnInvoiceRoundingOnAfterValidateQuantity(SalesHeader, SalesLine);            if SalesLine.IsCreditDocType() then                SalesLine.Validate("Return Qty. to Receive", SalesLine.Quantity)            else                SalesLine.Validate("Qty. to Ship", SalesLine.Quantity);            if SalesHeader."Prices Including VAT" then                SalesLine.Validate("Unit Price", InvoiceRoundingAmount)            else                SalesLine.Validate(                  "Unit Price",                  Round(                    InvoiceRoundingAmount /                    (1 + (1 - SalesLine.GetVatBaseDiscountPct(SalesHeader) / 100) * SalesLine."VAT %" / 100),                    Currency."Amount Rounding Precision"));            SalesLine.Validate("Amount Including VAT", InvoiceRoundingAmount);            SalesLine."Line No." := BiggestLineNo;            OnInvoiceRoundingOnAfterSetLineNo(SalesHeader, SalesLine);            LastLineRetrieved := false;            RoundingLineInserted := true;            RoundingLineNo := SalesLine."Line No.";        end;        OnAfterInvoiceRoundingAmount(            SalesHeader, SalesLine, TotalSalesLine, UseTempData, InvoiceRoundingAmount, SuppressCommit, Currency,            BiggestLineNo, LastLineRetrieved, RoundingLineInserted, RoundingLineNo);    end;    /// <summary>    /// Adds the amounts from sales line to the TotalSalesLine record.    /// </summary>    /// <param name="SalesHeader">The sales header of the document.</param>    /// <param name="SalesLine">The sales line to add the amounts from.</param>    /// <param name="TotalSalesLine">Return Variable: The TotalSalesLine record to which the amounts are added.</param>    procedure IncrAmount(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TotalSalesLine: Record "Sales Line")    begin        if SalesHeader."Prices Including VAT" or           (SalesLine."VAT Calculation Type" <> SalesLine."VAT Calculation Type"::"Full VAT")        then            TotalSalesLine."Line Amount" += SalesLine."Line Amount";        TotalSalesLine.Amount += SalesLine.Amount;        TotalSalesLine."VAT Base Amount" += SalesLine."VAT Base Amount";        TotalSalesLine."VAT Difference" += SalesLine."VAT Difference";        TotalSalesLine."Amount Including VAT" += SalesLine."Amount Including VAT";        TotalSalesLine."Line Discount Amount" += SalesLine."Line Discount Amount";        TotalSalesLine."Inv. Discount Amount" += SalesLine."Inv. Discount Amount";        TotalSalesLine."Inv. Disc. Amount to Invoice" += SalesLine."Inv. Disc. Amount to Invoice";        TotalSalesLine."Prepmt. Line Amount" += SalesLine."Prepmt. Line Amount";        TotalSalesLine."Prepmt. Amt. Inv." += SalesLine."Prepmt. Amt. Inv.";        TotalSalesLine."Prepmt Amt to Deduct" += SalesLine."Prepmt Amt to Deduct";        TotalSalesLine."Prepmt Amt Deducted" += SalesLine."Prepmt Amt Deducted";        TotalSalesLine."Prepayment VAT Difference" += SalesLine."Prepayment VAT Difference";        TotalSalesLine."Prepmt VAT Diff. to Deduct" += SalesLine."Prepmt VAT Diff. to Deduct";        TotalSalesLine."Prepmt VAT Diff. Deducted" += SalesLine."Prepmt VAT Diff. Deducted";        OnAfterIncrAmount(TotalSalesLine, SalesLine, SalesHeader);    end;    local procedure GetSalesHeader(var SalesHeader: Record "Sales Header")    var        SalesHeaderCopy: Record "Sales Header";    begin        SalesHeaderCopy := SalesHeader;        SalesHeader.ReadIsolation := IsolationLevel::ReadCommitted;        SalesHeader.Get(SalesHeader."Document Type", SalesHeader."No.");        SalesHeader := SalesHeaderCopy;    end;    /// <summary>    /// Collects the sales lines for the specified sales header and stores them in the NewSalesLine record set.    /// Collected lines will have the amounts divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType.    /// </summary>    /// <remarks>    /// An overload for GetSalesLines that always includes prepayments (if QtyType is set to Invoicing).    /// </remarks>    /// <param name="SalesHeader">The sales header of the document.</param>    /// <param name="NewSalesLine">Return Variable: The NewSalesLine record set to store the collected sales lines in. This should be a temporary variable as new records will be inserted.</param>    /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param>    procedure GetSalesLines(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping)    begin        GetSalesLines(SalesHeader, NewSalesLine, QtyType, true);    end;    /// <summary>    /// Collects and divides amounts of the sales lines for the specified sales header and stores them in the NewSalesLine record set.    /// Collected lines will have the amounts divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType.    /// </summary>    /// <param name="SalesHeader">The sales header of the document.</param>    /// <param name="NewSalesLine">Return Variable: The NewSalesLine record set to store the collected sales lines in. This should be a temporary variable as new records will be inserted.</param>    /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param>    /// <param name="IncludePrepayments">A flag indicating whether prepayments should be included in the collected lines. Only applies if QtyType is set to Invoicing.</param>    procedure GetSalesLines(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; IncludePrepayments: Boolean)    var        TotalAdjCostLCY: Decimal;    begin        OnBeforeGetSalesLines(SalesHeader, NewSalesLine, QtyType, IncludePrepayments);        FillTempLines(SalesHeader, TempSalesLineGlobal);        OnGetSalesLinesOnAfterFillTempLines(SalesHeader, TempSalesLineGlobal);        if (QtyType = QtyType::Invoicing) and IncludePrepayments then            CreatePrepaymentLines(SalesHeader, false);        SumSalesLines2(SalesHeader, NewSalesLine, TempSalesLineGlobal, QtyType, true, false, TotalAdjCostLCY, IncludePrepayments, false);        OnAfterGetSalesLines(SalesHeader, TempSalesLineGlobal, NewSalesLine);    end;    /// <summary>    /// Collects and divides amounts of the sales lines for the specified sales header and stores them in the NewSalesLine record set.    /// Collected lines will have the amounts divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType.    /// </summary>    /// <param name="SalesHeader">The sales header of the document.</param>    /// <param name="NewSalesLine">Return Variable: The NewSalesLine record set to store the collected sales lines in. This should be a temporary variable as new records will be inserted.</param>    /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param>    /// <param name="IncludePrepayments">A flag indicating whether prepayments should be included in the collected lines. Only applies if QtyType is set to Invoicing.</param>    /// <param name="CalledFromStatistics">A flag indicating whether the procedure is called from statistics.</param>    procedure GetSalesLines(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; IncludePrepayments: Boolean; CalledFromStatistics: Boolean)    var        TotalAdjCostLCY: Decimal;    begin        OnBeforeGetSalesLines(SalesHeader, NewSalesLine, QtyType, IncludePrepayments);        FillTempLines(SalesHeader, TempSalesLineGlobal);        OnGetSalesLinesOnAfterFillTempLines(SalesHeader, TempSalesLineGlobal);        if (QtyType = QtyType::Invoicing) and IncludePrepayments then            CreatePrepaymentLines(SalesHeader, false);        SumSalesLines2(SalesHeader, NewSalesLine, TempSalesLineGlobal, QtyType, true, false, TotalAdjCostLCY, IncludePrepayments, CalledFromStatistics);        OnAfterGetSalesLines(SalesHeader, TempSalesLineGlobal, NewSalesLine);    end;    /// <summary>    /// Divides amounts of the sales lines passed as OldSalesLine parameter and stores them in the NewSalesLine record set.    /// Lines will have the amounts divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType.    /// </summary>    /// <remarks>    /// Behaves similarly to GetSalesLines with the exception that GetSalesLines collects all the lines for the specified sales header,    /// while this method only divides the amounts of the lines passed as OldSalesLine parameter.    /// </remarks>    /// <param name="SalesHeader">The sales header of the document.</param>    /// <param name="NewSalesLine">Return Variable: The NewSalesLine record set to store the collected sales lines in. This should be a temporary variable as new records will be inserted.</param>    /// <param name="OldSalesLine">The sales line record set to copy the lines from and divide the amounts.</param>    /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param>    procedure GetSalesLinesTemp(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping)    var        TotalAdjCostLCY: Decimal;    begin        OnBeforeGetSalesLinesTemp(SalesHeader, NewSalesLine, OldSalesLine, QtyType);        OldSalesLine.SetSalesHeader(SalesHeader);        SumSalesLines2(SalesHeader, NewSalesLine, OldSalesLine, QtyType, true, false, TotalAdjCostLCY);    end;    /// <summary>    /// Sums the sales lines for the specified sales header (within the filters that are already set on OldSalesLine) and stores the results in the NewTotalSalesLine and NewTotalSalesLineLCY record variables.    /// The amounts will be divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType.    /// </summary>    /// <remarks>    /// This is an overload for SumSalesLineTemp that always includes prepayments in amount calculations    /// it always takes the lines for the specified sales header (doesn't support a parameter for filtered or temp sales lines).    /// </remarks>    /// <param name="NewSalesHeader">The sales header of the document.</param>    /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param>    /// <param name="NewTotalSalesLine">Return Variable: The NewTotalSalesLine record to store the summed amounts in.</param>    /// <param name="NewTotalSalesLineLCY">Return Variable: The NewTotalSalesLineLCY record to store the summed amounts in LCY in.</param>    /// <param name="VATAmount">Return Variable: The total VAT amount.</param>    /// <param name="VATAmountText">Return Variable: The text to display for the VAT amount. This will include the VAT rate if the VAT rate is the same for all lines.</param>    /// <param name="ProfitLCY">Return Variable: The total profit in LCY.</param>    /// <param name="ProfitPct">Return Variable: The total profit percentage.</param>    /// <param name="TotalAdjCostLCY">Return Variable: The total adjusted cost in LCY.</param>    procedure SumSalesLines(var NewSalesHeader: Record "Sales Header"; QtyType: Option General,Invoicing,Shipping; var NewTotalSalesLine: Record "Sales Line"; var NewTotalSalesLineLCY: Record "Sales Line"; var VATAmount: Decimal; var VATAmountText: Text[30]; var ProfitLCY: Decimal; var ProfitPct: Decimal; var TotalAdjCostLCY: Decimal)    var        OldSalesLine: Record "Sales Line";    begin        SumSalesLinesTemp(          NewSalesHeader, OldSalesLine, QtyType, NewTotalSalesLine, NewTotalSalesLineLCY,          VATAmount, VATAmountText, ProfitLCY, ProfitPct, TotalAdjCostLCY);    end;    /// <summary>    /// Sums the sales lines for the specified sales header (within the filters that are already set on OldSalesLine) and stores the results in the NewTotalSalesLine and NewTotalSalesLineLCY record variables.    /// The amounts will be divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType.    /// </summary>    /// <remarks>    /// OldSalesLine can be a temporary variable    /// This is an overload for SumSalesLineTemp that always includes prepayments in amount calculations    /// </remarks>    /// <param name="SalesHeader"></param>    /// <param name="OldSalesLine"></param>    /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param>    /// <param name="NewTotalSalesLine">Return Variable: The NewTotalSalesLine record to store the summed amounts in.</param>    /// <param name="NewTotalSalesLineLCY">Return Variable: The NewTotalSalesLineLCY record to store the summed amounts in LCY in.</param>    /// <param name="VATAmount">Return Variable: The total VAT amount.</param>    /// <param name="VATAmountText">Return Variable: The text to display for the VAT amount. This will include the VAT rate if the VAT rate is the same for all lines.</param>    /// <param name="ProfitLCY">Return Variable: The total profit in LCY.</param>    /// <param name="ProfitPct">Return Variable: The total profit percentage.</param>    /// <param name="TotalAdjCostLCY">Return Variable: The total adjusted cost in LCY.</param>    procedure SumSalesLinesTemp(var SalesHeader: Record "Sales Header"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; var NewTotalSalesLine: Record "Sales Line"; var NewTotalSalesLineLCY: Record "Sales Line"; var VATAmount: Decimal; var VATAmountText: Text[30]; var ProfitLCY: Decimal; var ProfitPct: Decimal; var TotalAdjCostLCY: Decimal)    begin        SumSalesLinesTemp(SalesHeader, OldSalesLine, QtyType, NewTotalSalesLine, NewTotalSalesLineLCY, VATAmount, VATAmountText, ProfitLCY, ProfitPct, TotalAdjCostLCY, true);    end;    /// <summary>    /// Sums the sales lines for the specified sales header (within the filters that are already set on OldSalesLine) and stores the results in the NewTotalSalesLine and NewTotalSalesLineLCY record variables.    /// The amounts will be divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType.    /// </summary>    /// <remarks>    /// OldSalesLine can be a temporary variable    /// </remarks>    /// <param name="SalesHeader">The sales header of the document.</param>    /// <param name="OldSalesLine">The sales lines to sum.</param>    /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param>    /// <param name="NewTotalSalesLine">Return Variable: The NewTotalSalesLine record to store the summed amounts in.</param>    /// <param name="NewTotalSalesLineLCY">Return Variable: The NewTotalSalesLineLCY record to store the summed amounts in LCY in.</param>    /// <param name="VATAmount">Return Variable: The total VAT amount.</param>    /// <param name="VATAmountText">Return Variable: The text to display for the VAT amount. This will include the VAT rate if the VAT rate is the same for all lines.</param>    /// <param name="ProfitLCY">Return Variable: The total profit in LCY.</param>    /// <param name="ProfitPct">Return Variable: The total profit percentage.</param>    /// <param name="TotalAdjCostLCY">Return Variable: The total adjusted cost in LCY.</param>    /// <param name="IncludePrepayments">A flag indicating whether prepayments should be included when calculating Line Amounts.</param>    procedure SumSalesLinesTemp(var SalesHeader: Record "Sales Header"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; var NewTotalSalesLine: Record "Sales Line"; var NewTotalSalesLineLCY: Record "Sales Line"; var VATAmount: Decimal; var VATAmountText: Text[30]; var ProfitLCY: Decimal; var ProfitPct: Decimal; var TotalAdjCostLCY: Decimal; IncludePrepayments: Boolean)    var        SalesLine: Record "Sales Line";    begin        OnBeforeSumSalesLinesTemp(SalesHeader, OldSalesLine);        SumSalesLines2(SalesHeader, SalesLine, OldSalesLine, QtyType, false, true, TotalAdjCostLCY, IncludePrepayments, false);        ProfitLCY := TotalSalesLineLCY.Amount - TotalSalesLineLCY."Unit Cost (LCY)";        if TotalSalesLineLCY.Amount = 0 then            ProfitPct := 0        else            ProfitPct := Round(ProfitLCY / TotalSalesLineLCY.Amount * 100, 0.1);        VATAmount := TotalSalesLine."Amount Including VAT" - TotalSalesLine.Amount;        OnSumSalesLinesTempOnAfterVatAmountSet(VATAmount, TotalSalesLine);        if TotalSalesLine."VAT %" = 0 then            VATAmountText := VATAmountTxt        else            VATAmountText := StrSubstNo(VATRateTxt, TotalSalesLine.GetVATPct());        NewTotalSalesLine := TotalSalesLine;        NewTotalSalesLineLCY := TotalSalesLineLCY;    end;    /// <summary>    /// Sums the sales lines for the specified sales header (within the filters that are already set on OldSalesLine) and stores the results in the NewTotalSalesLine and NewTotalSalesLineLCY record variables.    /// The amounts will be divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType.    /// </summary>    /// <remarks>    /// OldSalesLine can be a temporary variable    /// </remarks>    /// <param name="SalesHeader">The sales header of the document.</param>    /// <param name="OldSalesLine">The sales lines to sum.</param>    /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param>    /// <param name="NewTotalSalesLine">Return Variable: The NewTotalSalesLine record to store the summed amounts in.</param>    /// <param name="NewTotalSalesLineLCY">Return Variable: The NewTotalSalesLineLCY record to store the summed amounts in LCY in.</param>    /// <param name="VATAmount">Return Variable: The total VAT amount.</param>    /// <param name="VATAmountText">Return Variable: The text to display for the VAT amount. This will include the VAT rate if the VAT rate is the same for all lines.</param>    /// <param name="ProfitLCY">Return Variable: The total profit in LCY.</param>    /// <param name="ProfitPct">Return Variable: The total profit percentage.</param>    /// <param name="TotalAdjCostLCY">Return Variable: The total adjusted cost in LCY.</param>    /// <param name="IncludePrepayments">A flag indicating whether prepayments should be included when calculating Line Amounts.</param>    /// <param name="CalledFromStatistics">A flag indicating whether the procedure is called from statistics.</param>    procedure SumSalesLinesTemp(var SalesHeader: Record "Sales Header"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; var NewTotalSalesLine: Record "Sales Line"; var NewTotalSalesLineLCY: Record "Sales Line"; var VATAmount: Decimal; var VATAmountText: Text[30]; var ProfitLCY: Decimal; var ProfitPct: Decimal; var TotalAdjCostLCY: Decimal; IncludePrepayments: Boolean; CalledfromStatistics: Boolean)    var        SalesLine: Record "Sales Line";    begin        OnBeforeSumSalesLinesTemp(SalesHeader, OldSalesLine);        SumSalesLines2(SalesHeader, SalesLine, OldSalesLine, QtyType, false, true, TotalAdjCostLCY, IncludePrepayments, CalledfromStatistics);        ProfitLCY := TotalSalesLineLCY.Amount - TotalSalesLineLCY."Unit Cost (LCY)";        if TotalSalesLineLCY.Amount = 0 then            ProfitPct := 0        else            ProfitPct := Round(ProfitLCY / TotalSalesLineLCY.Amount * 100, 0.1);        VATAmount := TotalSalesLine."Amount Including VAT" - TotalSalesLine.Amount;        OnSumSalesLinesTempOnAfterVatAmountSet(VATAmount, TotalSalesLine);        if TotalSalesLine."VAT %" = 0 then            VATAmountText := VATAmountTxt        else            VATAmountText := StrSubstNo(VATRateTxt, TotalSalesLine.GetVATPct());        NewTotalSalesLine := TotalSalesLine;        NewTotalSalesLineLCY := TotalSalesLineLCY;    end;    local procedure SumSalesLines2(SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; InsertSalesLine: Boolean; CalcAdCostLCY: Boolean; var TotalAdjCostLCY: Decimal)    begin        SumSalesLines2(SalesHeader, NewSalesLine, OldSalesLine, QtyType, InsertSalesLine, CalcAdCostLCY, TotalAdjCostLCY, true, false);    end;    local procedure SumSalesLines2(SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; InsertSalesLine: Boolean; CalcAdCostLCY: Boolean; var TotalAdjCostLCY: Decimal; IncludePrepayments: Boolean; CalledfromStatistics: Boolean)    var        SalesLine: Record "Sales Line";        TempVATAmountLine: Record "VAT Amount Line" temporary;        TempVATAmountLineRemainder: Record "VAT Amount Line" temporary;        SalesLineQty: Decimal;        AdjCostLCY: Decimal;        BiggestLineNo: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSumSalesLines2(SalesHeader, NewSalesLine, OldSalesLine, QtyType, InsertSalesLine, CalcAdCostLCY, TotalAdjCostLCY, IncludePrepayments, IsHandled);        if IsHandled then            exit;        TotalAdjCostLCY := 0;        TempVATAmountLineRemainder.DeleteAll();        IsHandled := false;        OnSumSalesLines2OnBeforeCalcVATAmountLines(OldSalesLine, SalesHeader, InsertSalesLine, TempVATAmountLine, QtyType, IsHandled);        if not IsHandled then            OldSalesLine.CalcVATAmountLines(QtyType, SalesHeader, OldSalesLine, TempVATAmountLine, IncludePrepayments);        GetGLSetup();        GetSalesSetup();        GetCurrency(SalesHeader."Currency Code");        OldSalesLine.SetRange("Document Type", SalesHeader."Document Type");        OldSalesLine.SetRange("Document No.", SalesHeader."No.");        OnSumSalesLines2SetFilter(OldSalesLine, SalesHeader, InsertSalesLine, QtyType);        RoundingLineInserted := false;        if OldSalesLine.FindSet() then            repeat                if not RoundingLineInserted then                    SalesLine := OldSalesLine;                SalesLineQty := GetSalesLineQty(SalesHeader, SalesLine, QtyType, CalledfromStatistics);                IsHandled := false;                OnSumSalesLines2OnBeforeDivideAmount(                    OldSalesLine, IsHandled, SalesHeader, SalesLine, QtyType, SalesLineQty, TempVATAmountLine, TempVATAmountLineRemainder,                    IncludePrepayments, RoundingLineInserted);                if not IsHandled then                    DivideAmount(SalesHeader, SalesLine, QtyType, SalesLineQty, TempVATAmountLine, TempVATAmountLineRemainder, IncludePrepayments);                OnSumSalesLines2OnAfterDivideAmount(OldSalesLine, SalesLineQty, QtyType);                SalesLine.Quantity := SalesLineQty;                if SalesLineQty <> 0 then begin                    if (SalesLine.Amount <> 0) and not RoundingLineInserted then                        if TotalSalesLine.Amount = 0 then                            TotalSalesLine."VAT %" := SalesLine."VAT %"                        else                            if TotalSalesLine."VAT %" <> SalesLine."VAT %" then                                TotalSalesLine."VAT %" := 0;                    RoundAmount(SalesHeader, SalesLine, SalesLineQty);                    if (QtyType in [QtyType::General, QtyType::Invoicing]) and                       not InsertSalesLine and CalcAdCostLCY                    then begin                        AdjCostLCY := CostCalcMgt.CalcSalesLineCostLCY(SalesLine, QtyType);                        TotalAdjCostLCY := TotalAdjCostLCY + GetSalesLineAdjCostLCY(SalesLine, QtyType, AdjCostLCY);                        OnSumSalesLines2OnAfterCalcTotalAdjCostLCY(TotalAdjCostLCY, SalesLine);                    end;                    SalesLine := xSalesLine;                end;                if InsertSalesLine then begin                    NewSalesLine := SalesLine;                    IsHandled := false;                    OnSumSalesLines2OnBeforeNewSalesLineInsert(NewSalesLine, IsHandled);                    if not IsHandled then                        NewSalesLine.Insert();                end;                if RoundingLineInserted then                    LastLineRetrieved := true                else begin                    BiggestLineNo := MAX(BiggestLineNo, OldSalesLine."Line No.");                    LastLineRetrieved := OldSalesLine.Next() = 0;                    if LastLineRetrieved and SalesSetup."Invoice Rounding" then                        InvoiceRounding(SalesHeader, SalesLine, true, BiggestLineNo);                end;                OnAfterUpdateInvoiceRounding(                    SalesHeader, TotalSalesLine, SalesLine, Currency, BiggestLineNo, LastLineRetrieved, RoundingLineInserted, RoundingLineNo, true);            until LastLineRetrieved;        OnAfterSumSalesLines2(SalesHeader, OldSalesLine, NewSalesLine);    end;    local procedure GetSalesLineQty(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; CalledFromStatistics: Boolean) SalesLineQty: Decimal;    var        IsHandled: Boolean;    begin        if (CalledFromStatistics) and (not RoundingLineInserted) and (IsInvoiceRoundingLine(SalesHeader, SalesLine)) and (SalesLine."System-Created Entry") then            exit;        IsHandled := false;        OnBeforeGetSalesLineQty(SalesLine, QtyType, SalesLineQty, IsHandled);        if IsHandled then            exit(SalesLineQty);        case QtyType of            QtyType::General:                SalesLineQty := SalesLine.Quantity;            QtyType::Invoicing:                SalesLineQty := SalesLine."Qty. to Invoice";            QtyType::Shipping:                if SalesHeader.IsCreditDocType() then                    SalesLineQty := SalesLine."Return Qty. to Receive"                else                    SalesLineQty := SalesLine."Qty. to Ship";        end;    end;    local procedure GetSalesLineAdjCostLCY(SalesLine2: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; AdjCostLCY: Decimal): Decimal    var        IsHandled: Boolean;        Result: Decimal;    begin        IsHandled := false;        OnBeforeGetSalesLineAdjCostLCY(SalesLine2, QtyType, AdjCostLCY, Result, IsHandled);        if IsHandled then            exit(Result);        if SalesLine2."Document Type" in [SalesLine2."Document Type"::Order, SalesLine2."Document Type"::Invoice] then            AdjCostLCY := -AdjCostLCY;        case true of            SalesLine2."Shipment No." <> '', SalesLine2."Return Receipt No." <> '':                exit(AdjCostLCY);            QtyType = QtyType::General:                exit(Round(SalesLine2."Outstanding Quantity" * SalesLine2."Unit Cost (LCY)") + AdjCostLCY);            SalesLine2."Document Type" in [SalesLine2."Document Type"::Order, SalesLine2."Document Type"::Invoice]:                begin                    if SalesLine2."Qty. to Invoice" > SalesLine2."Qty. to Ship" then                        exit(Round(SalesLine2."Qty. to Ship" * SalesLine2."Unit Cost (LCY)") + AdjCostLCY);                    exit(Round(SalesLine2."Qty. to Invoice" * SalesLine2."Unit Cost (LCY)"));                end;            SalesLine2.IsCreditDocType():                begin                    if SalesLine2."Qty. to Invoice" > SalesLine2."Return Qty. to Receive" then                        exit(Round(SalesLine2."Return Qty. to Receive" * SalesLine2."Unit Cost (LCY)") + AdjCostLCY);                    exit(Round(SalesLine2."Qty. to Invoice" * SalesLine2."Unit Cost (LCY)"));                end;        end;    end;    /// <summary>    /// Updated the related blanket order line for the quantities that are shipped, received or invoiced with the specified sales line.    /// </summary>    /// <param name="SalesLine">The sales line to update the blanket order line for.</param>    /// <param name="Ship">A flag indicating whether the sales line is being shipped.</param>    /// <param name="Receive">A flag indicating whether the sales line is being received (Return Orders).</param>    /// <param name="Invoice">A flag indicating whether the sales line is being invoiced.</param>    procedure UpdateBlanketOrderLine(SalesLine: Record "Sales Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean)    var        BlanketOrderSalesLine: Record "Sales Line";        xBlanketOrderSalesLine: Record "Sales Line";        ModifyLine: Boolean;        Sign: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateBlanketOrderLine(SalesLine, Ship, Receive, Invoice, IsHandled);        if IsHandled then            exit;        if (SalesLine."Blanket Order No." <> '') and (SalesLine."Blanket Order Line No." <> 0) and           ((Ship and (SalesLine."Qty. to Ship" <> 0)) or            (Receive and (SalesLine."Return Qty. to Receive" <> 0)) or            (Invoice and (SalesLine."Qty. to Invoice" <> 0)))        then            if BlanketOrderSalesLine.Get(                 BlanketOrderSalesLine."Document Type"::"Blanket Order", SalesLine."Blanket Order No.",                 SalesLine."Blanket Order Line No.")            then begin                BlanketOrderSalesLine.TestField(Type, SalesLine.Type);                BlanketOrderSalesLine.TestField("No.", SalesLine."No.");                IsHandled := false;                OnUpdateBlanketOrderLineOnBeforeCheckSellToCustomerNo(BlanketOrderSalesLine, SalesLine, IsHandled);                if not IsHandled then                    BlanketOrderSalesLine.TestField("Sell-to Customer No.", SalesLine."Sell-to Customer No.");                ModifyLine := false;                case SalesLine."Document Type" of                    SalesLine."Document Type"::Order,                  SalesLine."Document Type"::Invoice:                        Sign := 1;                    SalesLine."Document Type"::"Return Order",                  SalesLine."Document Type"::"Credit Memo":                        Sign := -1;                end;                if Ship and (SalesLine."Shipment No." = '') then begin                    xBlanketOrderSalesLine := BlanketOrderSalesLine;                    if BlanketOrderSalesLine."Qty. per Unit of Measure" = SalesLine."Qty. per Unit of Measure" then                        BlanketOrderSalesLine."Quantity Shipped" += Sign * SalesLine."Qty. to Ship"                    else                        BlanketOrderSalesLine."Quantity Shipped" +=                          Sign *                          Round(                            (SalesLine."Qty. per Unit of Measure" /                             BlanketOrderSalesLine."Qty. per Unit of Measure") * SalesLine."Qty. to Ship",                            UOMMgt.QtyRndPrecision());                    BlanketOrderSalesLine."Qty. Shipped (Base)" += Sign * SalesLine."Qty. to Ship (Base)";                    ModifyLine := true;                    AsmPost.UpdateBlanketATO(xBlanketOrderSalesLine, BlanketOrderSalesLine);                end;                if Receive and (SalesLine."Return Receipt No." = '') then begin                    if BlanketOrderSalesLine."Qty. per Unit of Measure" =                       SalesLine."Qty. per Unit of Measure"                    then                        BlanketOrderSalesLine."Quantity Shipped" += Sign * SalesLine."Return Qty. to Receive"                    else                        BlanketOrderSalesLine."Quantity Shipped" +=                          Sign *                          Round(                            (SalesLine."Qty. per Unit of Measure" /                             BlanketOrderSalesLine."Qty. per Unit of Measure") * SalesLine."Return Qty. to Receive",                            UOMMgt.QtyRndPrecision());                    BlanketOrderSalesLine."Qty. Shipped (Base)" += Sign * SalesLine."Return Qty. to Receive (Base)";                    ModifyLine := true;                end;                if Invoice then begin                    if BlanketOrderSalesLine."Qty. per Unit of Measure" =                       SalesLine."Qty. per Unit of Measure"                    then                        BlanketOrderSalesLine."Quantity Invoiced" += Sign * SalesLine."Qty. to Invoice"                    else                        BlanketOrderSalesLine."Quantity Invoiced" +=                          Sign *                          Round(                            (SalesLine."Qty. per Unit of Measure" /                             BlanketOrderSalesLine."Qty. per Unit of Measure") * SalesLine."Qty. to Invoice",                            UOMMgt.QtyRndPrecision());                    BlanketOrderSalesLine."Qty. Invoiced (Base)" += Sign * SalesLine."Qty. to Invoice (Base)";                    ModifyLine := true;                end;                if ModifyLine then begin                    OnUpdateBlanketOrderLineOnBeforeInitOutstanding(BlanketOrderSalesLine, SalesLine, Ship, Receive, Invoice);                    BlanketOrderSalesLine.InitOutstanding();                    IsHandled := false;                    OnUpdateBlanketOrderLineOnBeforeCheck(BlanketOrderSalesLine, SalesLine, IsHandled);                    if not IsHandled then begin                        if (BlanketOrderSalesLine.Quantity * BlanketOrderSalesLine."Quantity Shipped" < 0) or                           (Abs(BlanketOrderSalesLine.Quantity) < Abs(BlanketOrderSalesLine."Quantity Shipped"))                        then                            BlanketOrderSalesLine.FieldError(                              "Quantity Shipped", StrSubstNo(BlanketOrderQuantityGreaterThanErr, BlanketOrderSalesLine.FieldCaption(Quantity)));                        if (BlanketOrderSalesLine."Quantity (Base)" * BlanketOrderSalesLine."Qty. Shipped (Base)" < 0) or                           (Abs(BlanketOrderSalesLine."Quantity (Base)") < Abs(BlanketOrderSalesLine."Qty. Shipped (Base)"))                        then                            BlanketOrderSalesLine.FieldError(                              "Qty. Shipped (Base)",                              StrSubstNo(BlanketOrderQuantityGreaterThanErr, BlanketOrderSalesLine.FieldCaption("Quantity (Base)")));                        BlanketOrderSalesLine.CalcFields("Reserved Qty. (Base)");                        if Abs(BlanketOrderSalesLine."Outstanding Qty. (Base)") < Abs(BlanketOrderSalesLine."Reserved Qty. (Base)") then                            BlanketOrderSalesLine.FieldError(                              "Reserved Qty. (Base)", BlanketOrderQuantityReducedErr);                    end;                    BlanketOrderSalesLine."Qty. to Invoice" :=                        BlanketOrderSalesLine.Quantity - BlanketOrderSalesLine."Quantity Invoiced";                    if (SalesLine.Quantity = SalesLine."Quantity Shipped") or (SalesLine."Quantity Shipped" = 0) then                        BlanketOrderSalesLine."Qty. to Ship" :=                            BlanketOrderSalesLine.Quantity - BlanketOrderSalesLine."Quantity Shipped";                    BlanketOrderSalesLine."Qty. to Invoice (Base)" :=                        BlanketOrderSalesLine."Quantity (Base)" - BlanketOrderSalesLine."Qty. Invoiced (Base)";                    if (SalesLine."Quantity (Base)" = SalesLine."Qty. Shipped (Base)") or (SalesLine."Qty. Shipped (Base)" = 0) then                        BlanketOrderSalesLine."Qty. to Ship (Base)" :=                            BlanketOrderSalesLine."Quantity (Base)" - BlanketOrderSalesLine."Qty. Shipped (Base)";                    OnBeforeBlanketOrderSalesLineModify(BlanketOrderSalesLine, SalesLine);                    BlanketOrderSalesLine.Modify();                    OnAfterUpdateBlanketOrderLine(BlanketOrderSalesLine, SalesLine, Ship, Receive, Invoice);                end;            end;    end;    local procedure DeleteItemChargeAssgnt(SalesHeader: Record "Sales Header")    var        ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)";    begin        ItemChargeAssgntSales.SetRange("Document Type", SalesHeader."Document Type");        ItemChargeAssgntSales.SetRange("Document No.", SalesHeader."No.");        if not ItemChargeAssgntSales.IsEmpty() then            ItemChargeAssgntSales.DeleteAll();    end;    local procedure UpdateItemChargeAssgnt(var SalesHeader: Record "Sales Header")    var        ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)";    begin        ClearItemChargeAssgntFilter();        TempItemChargeAssgntSales.MarkedOnly(true);        if TempItemChargeAssgntSales.FindSet() then            repeat                ItemChargeAssgntSales.Get(TempItemChargeAssgntSales."Document Type", TempItemChargeAssgntSales."Document No.", TempItemChargeAssgntSales."Document Line No.", TempItemChargeAssgntSales."Line No.");                ItemChargeAssgntSales."Qty. Assigned" += ItemChargeAssgntSales."Qty. to Handle";                ItemChargeAssgntSales."Qty. to Assign" -= ItemChargeAssgntSales."Qty. to Handle";                ItemChargeAssgntSales."Amount to Assign" -= ItemChargeAssgntSales."Amount to Handle";                ItemChargeAssgntSales."Qty. to Handle" := 0;                ItemChargeAssgntSales."Amount to Handle" := 0;                ItemChargeAssgntSales.Modify();            until TempItemChargeAssgntSales.Next() = 0;        OnAfterUpdateItemChargeAssgnt(SalesHeader);    end;    /// <summary>    /// Updates the Item Charge Assignment (Sales) lines quantities for the quantity that was posted for the specified sales line.    /// </summary>    /// <param name="SalesOrderInvLine">sales line of type Charge (Item) for the document being posted which is of type Invoice or Credit Memo</param>    /// <param name="SalesOrderLine">sales line of  document type Order or Return Order that is related to the SalesOrderInvLine</param>    procedure UpdateSalesOrderChargeAssgnt(SalesOrderInvLine: Record "Sales Line"; SalesOrderLine: Record "Sales Line")    var        SalesOrderLine2: Record "Sales Line";        SalesOrderInvLine2: Record "Sales Line";        SalesShptLine: Record "Sales Shipment Line";        ReturnRcptLine: Record "Return Receipt Line";    begin        ClearItemChargeAssgntFilter();        TempItemChargeAssgntSales.SetRange("Document Type", SalesOrderInvLine."Document Type");        TempItemChargeAssgntSales.SetRange("Document No.", SalesOrderInvLine."Document No.");        TempItemChargeAssgntSales.SetRange("Document Line No.", SalesOrderInvLine."Line No.");        TempItemChargeAssgntSales.MarkedOnly(true);        if TempItemChargeAssgntSales.FindSet() then            repeat                if TempItemChargeAssgntSales."Applies-to Doc. Type" = SalesOrderInvLine."Document Type" then begin                    SalesOrderInvLine2.Get(                      TempItemChargeAssgntSales."Applies-to Doc. Type",                      TempItemChargeAssgntSales."Applies-to Doc. No.",                      TempItemChargeAssgntSales."Applies-to Doc. Line No.");                    if SalesOrderLine."Document Type" = SalesOrderLine."Document Type"::Order then begin                        if not                           SalesShptLine.Get(SalesOrderInvLine2."Shipment No.", SalesOrderInvLine2."Shipment Line No.")                        then                            Error(ShipmentLinesDeletedErr);                        SalesOrderLine2.Get(                          SalesOrderLine2."Document Type"::Order,                          SalesShptLine."Order No.", SalesShptLine."Order Line No.");                    end else begin                        if not                           ReturnRcptLine.Get(SalesOrderInvLine2."Return Receipt No.", SalesOrderInvLine2."Return Receipt Line No.")                        then                            Error(ReturnReceiptLinesDeletedErr);                        SalesOrderLine2.Get(                          SalesOrderLine2."Document Type"::"Return Order",                          ReturnRcptLine."Return Order No.", ReturnRcptLine."Return Order Line No.");                    end;                    UpdateSalesChargeAssgntLines(                      SalesOrderLine,                      SalesOrderLine2."Document Type",                      SalesOrderLine2."Document No.",                      SalesOrderLine2."Line No.",                      TempItemChargeAssgntSales."Qty. to Handle");                end else                    UpdateSalesChargeAssgntLines(                      SalesOrderLine,                      TempItemChargeAssgntSales."Applies-to Doc. Type",                      TempItemChargeAssgntSales."Applies-to Doc. No.",                      TempItemChargeAssgntSales."Applies-to Doc. Line No.",                      TempItemChargeAssgntSales."Qty. to Handle");            until TempItemChargeAssgntSales.Next() = 0;    end;    local procedure UpdateSalesChargeAssgntLines(SalesOrderLine: Record "Sales Line"; ApplToDocType: Enum "Sales Applies-to Document Type"; ApplToDocNo: Code[20]; ApplToDocLineNo: Integer; QtyToHandle: Decimal)    var        ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)";        TempItemChargeAssgntSales2: Record "Item Charge Assignment (Sales)";        LastLineNo: Integer;        TotalToAssign: Decimal;    begin        ItemChargeAssgntSales.SetRange("Document Type", SalesOrderLine."Document Type");        ItemChargeAssgntSales.SetRange("Document No.", SalesOrderLine."Document No.");        ItemChargeAssgntSales.SetRange("Document Line No.", SalesOrderLine."Line No.");        ItemChargeAssgntSales.SetRange("Applies-to Doc. Type", ApplToDocType);        ItemChargeAssgntSales.SetRange("Applies-to Doc. No.", ApplToDocNo);        ItemChargeAssgntSales.SetRange("Applies-to Doc. Line No.", ApplToDocLineNo);        if ItemChargeAssgntSales.FindFirst() then begin            ItemChargeAssgntSales."Qty. Assigned" += QtyToHandle;            ItemChargeAssgntSales."Qty. to Assign" -= QtyToHandle;            ItemChargeAssgntSales."Qty. to Handle" -= QtyToHandle;            if ItemChargeAssgntSales."Qty. to Assign" < 0 then                ItemChargeAssgntSales."Qty. to Assign" := 0;            ItemChargeAssgntSales."Amount to Assign" :=              Round(ItemChargeAssgntSales."Qty. to Assign" * ItemChargeAssgntSales."Unit Cost", Currency."Amount Rounding Precision");            if ItemChargeAssgntSales."Qty. to Handle" < 0 then                ItemChargeAssgntSales."Qty. to Handle" := 0;            ItemChargeAssgntSales."Amount to Handle" :=              Round(ItemChargeAssgntSales."Qty. to Handle" * ItemChargeAssgntSales."Unit Cost", Currency."Amount Rounding Precision");            ItemChargeAssgntSales.Modify();        end else begin            ItemChargeAssgntSales.SetRange("Applies-to Doc. Type");            ItemChargeAssgntSales.SetRange("Applies-to Doc. No.");            ItemChargeAssgntSales.SetRange("Applies-to Doc. Line No.");            ItemChargeAssgntSales.CalcSums("Qty. to Assign", "Qty. to Handle");            // calculate total qty. to assign of the invoice charge line            TempItemChargeAssgntSales2.SetRange("Document Type", TempItemChargeAssgntSales."Document Type");            TempItemChargeAssgntSales2.SetRange("Document No.", TempItemChargeAssgntSales."Document No.");            TempItemChargeAssgntSales2.SetRange("Document Line No.", TempItemChargeAssgntSales."Document Line No.");            TempItemChargeAssgntSales2.CalcSums("Qty. to Assign", "Qty. to Handle");            TotalToAssign := ItemChargeAssgntSales."Qty. to Handle" + TempItemChargeAssgntSales2."Qty. to Handle";            if ItemChargeAssgntSales.FindLast() then                LastLineNo := ItemChargeAssgntSales."Line No.";            if SalesOrderLine.Quantity < TotalToAssign then                repeat                    TotalToAssign -= ItemChargeAssgntSales."Qty. to Handle";                    ItemChargeAssgntSales."Qty. to Assign" -= ItemChargeAssgntSales."Qty. to Handle";                    ItemChargeAssgntSales."Amount to Assign" -= ItemChargeAssgntSales."Amount to Handle";                    ItemChargeAssgntSales."Qty. to Handle" := 0;                    ItemChargeAssgntSales."Amount to Handle" := 0;                    ItemChargeAssgntSales.Modify();                until (ItemChargeAssgntSales.Next(-1) = 0) or (TotalToAssign = SalesOrderLine.Quantity);            InsertAssocOrderCharge(              SalesOrderLine, ApplToDocType, ApplToDocNo, ApplToDocLineNo, LastLineNo,              TempItemChargeAssgntSales."Applies-to Doc. Line Amount");        end;    end;    local procedure InsertAssocOrderCharge(SalesOrderLine: Record "Sales Line"; ApplToDocType: Enum "Sales Applies-to Document Type"; ApplToDocNo: Code[20]; ApplToDocLineNo: Integer; LastLineNo: Integer; ApplToDocLineAmt: Decimal)    var        NewItemChargeAssgntSales: Record "Item Charge Assignment (Sales)";    begin        NewItemChargeAssgntSales.Init();        NewItemChargeAssgntSales."Document Type" := SalesOrderLine."Document Type";        NewItemChargeAssgntSales."Document No." := SalesOrderLine."Document No.";        NewItemChargeAssgntSales."Document Line No." := SalesOrderLine."Line No.";        NewItemChargeAssgntSales."Line No." := LastLineNo + 10000;        NewItemChargeAssgntSales."Item Charge No." := TempItemChargeAssgntSales."Item Charge No.";        NewItemChargeAssgntSales."Item No." := TempItemChargeAssgntSales."Item No.";        NewItemChargeAssgntSales."Qty. Assigned" := TempItemChargeAssgntSales."Qty. to Handle";        NewItemChargeAssgntSales."Qty. to Handle" := 0;        NewItemChargeAssgntSales."Amount to Handle" := 0;        NewItemChargeAssgntSales.Description := TempItemChargeAssgntSales.Description;        NewItemChargeAssgntSales."Unit Cost" := TempItemChargeAssgntSales."Unit Cost";        NewItemChargeAssgntSales."Applies-to Doc. Type" := ApplToDocType;        NewItemChargeAssgntSales."Applies-to Doc. No." := ApplToDocNo;        NewItemChargeAssgntSales."Applies-to Doc. Line No." := ApplToDocLineNo;        NewItemChargeAssgntSales."Applies-to Doc. Line Amount" := ApplToDocLineAmt;        OnInsertAssocOrderChargeOnBeforeNewItemChargeAssgntSalesInsert(TempItemChargeAssgntSales, NewItemChargeAssgntSales);        NewItemChargeAssgntSales.Insert();    end;    /// <summary>    /// Copies and validates item charge assignments for posting.    /// </summary>    /// <param name="SalesHeader">The sales header record to process item charges for.</param>    procedure CopyAndCheckItemCharge(SalesHeader: Record "Sales Header")    var        TempSalesLine: Record "Sales Line" temporary;        SalesLine: Record "Sales Line";        InvoiceEverything: Boolean;        AssignError: Boolean;        SkipTestJobNo: Boolean;        QtyNeeded: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCopyAndCheckItemCharge(            SalesHeader, TempSalesLine, SalesLine, InvoiceEverything, AssignError, QtyNeeded, TempItemChargeAssgntSales, ItemChargeAssgntSales, TempSalesLineGlobal, IsHandled);        if IsHandled then            exit;        TempItemChargeAssgntSales.Reset();        TempItemChargeAssgntSales.DeleteAll();        // Check for max qty posting        ResetTempLines(TempSalesLine);        TempSalesLine.SetRange(Type, TempSalesLine.Type::"Charge (Item)");        if TempSalesLine.IsEmpty() then            exit;        CopyItemChargeForSalesLine(TempItemChargeAssgntSales, TempSalesLine);        TempSalesLine.SetFilter("Qty. to Invoice", '<>0');        if TempSalesLine.FindSet() then            repeat                SkipTestJobNo := false;                OnCopyAndCheckItemChargeOnBeforeLoop(TempSalesLine, SalesHeader, SkipTestJobNo);                if not SkipTestJobNo then begin                    TempSalesLine.TestField("Job No.", '', ErrorInfo.Create());                    TempSalesLine.TestField("Job Contract Entry No.", 0, ErrorInfo.Create());                end;                if (TempSalesLine."Qty. to Ship" + TempSalesLine."Return Qty. to Receive" <> 0) and                   ((SalesHeader.Ship or SalesHeader.Receive) or                    (Abs(TempSalesLine."Qty. to Invoice") >                     Abs(TempSalesLine."Qty. Shipped Not Invoiced" + TempSalesLine."Qty. to Ship") +                     Abs(TempSalesLine."Ret. Qty. Rcd. Not Invd.(Base)" + TempSalesLine."Return Qty. to Receive")))                then                    TempSalesLine.TestField("Line Amount", ErrorInfo.Create());                if not SalesHeader.Ship then                    TempSalesLine."Qty. to Ship" := 0;                if not SalesHeader.Receive then                    TempSalesLine."Return Qty. to Receive" := 0;                IsHandled := false;                OnCopyAndCheckItemChargeOnBeforeAssignQtyToInvoice(TempSalesLine, IsHandled);                if not IsHandled then                    if Abs(TempSalesLine."Qty. to Invoice") >                        Abs(TempSalesLine."Quantity Shipped" + TempSalesLine."Qty. to Ship" + TempSalesLine."Return Qty. Received" + TempSalesLine."Return Qty. to Receive" - TempSalesLine."Quantity Invoiced")                    then                        TempSalesLine."Qty. to Invoice" :=                        TempSalesLine."Quantity Shipped" + TempSalesLine."Qty. to Ship" + TempSalesLine."Return Qty. Received" + TempSalesLine."Return Qty. to Receive" - TempSalesLine."Quantity Invoiced";                TempSalesLine.CalcFields("Qty. to Assign", "Qty. Assigned", "Item Charge Qty. to Handle");                if Abs(TempSalesLine."Item Charge Qty. to Handle" + TempSalesLine."Qty. Assigned") > Abs(TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced") then begin                    AdjustQtyToAssignForSalesLine(TempSalesLine);                    TempSalesLine.CalcFields("Qty. to Assign", "Qty. Assigned", "Item Charge Qty. to Handle");                    if Abs(TempSalesLine."Item Charge Qty. to Handle" + TempSalesLine."Qty. Assigned") > Abs(TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced") then                        Error(CannotAssignMoreErr,                          TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced" - TempSalesLine."Qty. Assigned",                          TempSalesLine.FieldCaption("Document Type"), TempSalesLine."Document Type",                          TempSalesLine.FieldCaption("Document No."), TempSalesLine."Document No.",                          TempSalesLine.FieldCaption("Line No."), TempSalesLine."Line No.");                    CopyItemChargeForSalesLine(TempItemChargeAssgntSales, TempSalesLine);                end;                if TempSalesLine.Quantity = TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced" then begin                    if TempSalesLine."Item Charge Qty. to Handle" <> 0 then                        if TempSalesLine.Quantity = TempSalesLine."Quantity Invoiced" then begin                            TempItemChargeAssgntSales.SetRange("Document Line No.", TempSalesLine."Line No.");                            TempItemChargeAssgntSales.SetRange("Applies-to Doc. Type", TempSalesLine."Document Type");                            if TempItemChargeAssgntSales.FindSet() then                                repeat                                    SalesLine.Get(                                      TempItemChargeAssgntSales."Applies-to Doc. Type",                                      TempItemChargeAssgntSales."Applies-to Doc. No.",                                      TempItemChargeAssgntSales."Applies-to Doc. Line No.");                                    if SalesLine.Quantity = SalesLine."Quantity Invoiced" then                                        Error(CannotAssignInvoicedErr, SalesLine.TableCaption(),                                          SalesLine.FieldCaption("Document Type"), SalesLine."Document Type",                                          SalesLine.FieldCaption("Document No."), SalesLine."Document No.",                                          SalesLine.FieldCaption("Line No."), SalesLine."Line No.");                                until TempItemChargeAssgntSales.Next() = 0;                        end;                    if TempSalesLine.Quantity <> TempSalesLine."Item Charge Qty. to Handle" + TempSalesLine."Qty. Assigned" then                        AssignError := true;                end;                if (TempSalesLine."Item Charge Qty. to Handle" + TempSalesLine."Qty. Assigned") < (TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced") then                    Error(MustAssignItemChargeErr, TempSalesLine."No.");                // check if all ILEs exist                QtyNeeded := TempSalesLine."Item Charge Qty. to Handle";                TempItemChargeAssgntSales.SetRange("Document Line No.", TempSalesLine."Line No.");                if TempItemChargeAssgntSales.FindSet() then                    repeat                        if (TempItemChargeAssgntSales."Applies-to Doc. Type" <> TempSalesLine."Document Type") or                           (TempItemChargeAssgntSales."Applies-to Doc. No." <> TempSalesLine."Document No.")                        then                            QtyNeeded := QtyNeeded - TempItemChargeAssgntSales."Qty. to Handle"                        else begin                            SalesLine.Get(                              TempItemChargeAssgntSales."Applies-to Doc. Type",                              TempItemChargeAssgntSales."Applies-to Doc. No.",                              TempItemChargeAssgntSales."Applies-to Doc. Line No.");                            if ItemLedgerEntryExist(SalesLine, SalesHeader.Ship or SalesHeader.Receive) then                                QtyNeeded := QtyNeeded - TempItemChargeAssgntSales."Qty. to Handle";                        end;                    until TempItemChargeAssgntSales.Next() = 0;                if QtyNeeded <> 0 then                    Error(CannotInvoiceItemChargeErr, TempSalesLine."No.");            until TempSalesLine.Next() = 0;        // Check saleslines        if AssignError then            if SalesHeader."Document Type" in               [SalesHeader."Document Type"::Invoice, SalesHeader."Document Type"::"Credit Memo"]            then                InvoiceEverything := true            else begin                TempSalesLine.Reset();                TempSalesLine.SetFilter(Type, '%1|%2', TempSalesLine.Type::Item, TempSalesLine.Type::"Charge (Item)");                if TempSalesLine.FindSet() then                    repeat                        if SalesHeader.Ship or SalesHeader.Receive then                            InvoiceEverything :=                              TempSalesLine.Quantity = TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced"                        else                            InvoiceEverything :=                              (TempSalesLine.Quantity = TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced") and                              (TempSalesLine."Qty. to Invoice" =                               TempSalesLine."Qty. Shipped Not Invoiced" + TempSalesLine."Ret. Qty. Rcd. Not Invd.(Base)");                    until (TempSalesLine.Next() = 0) or (not InvoiceEverything);            end;        OnCopyAndCheckItemChargeOnBeforeError(SalesHeader, TempSalesLine, InvoiceEverything);        if InvoiceEverything and AssignError then            Error(MustAssignErr);    end;    local procedure CopyItemChargeForSalesLine(var TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; SalesLine: Record "Sales Line")    var        ItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)";    begin        TempItemChargeAssignmentSales.Reset();        TempItemChargeAssignmentSales.SetRange("Document Type", SalesLine."Document Type");        TempItemChargeAssignmentSales.SetRange("Document No.", SalesLine."Document No.");        if not TempItemChargeAssignmentSales.IsEmpty() then            TempItemChargeAssignmentSales.DeleteAll();        ItemChargeAssignmentSales.CopyFilters(TempItemChargeAssignmentSales);        ItemChargeAssignmentSales.SetFilter("Qty. to Handle", '<>0');        if ItemChargeAssignmentSales.FindSet() then            repeat                TempItemChargeAssignmentSales.Init();                TempItemChargeAssignmentSales := ItemChargeAssignmentSales;                TempItemChargeAssignmentSales.Insert();            until ItemChargeAssignmentSales.Next() = 0;    end;    local procedure AdjustQtyToAssignForSalesLine(var TempSalesLine: Record "Sales Line" temporary)    var        ItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)";        Delta: Decimal;        QtyToHandle: Decimal;    begin        TempSalesLine.CalcFields("Qty. to Assign");        ItemChargeAssignmentSales.Reset();        ItemChargeAssignmentSales.SetRange("Document Type", TempSalesLine."Document Type");        ItemChargeAssignmentSales.SetRange("Document No.", TempSalesLine."Document No.");        ItemChargeAssignmentSales.SetRange("Document Line No.", TempSalesLine."Line No.");        ItemChargeAssignmentSales.SetFilter("Qty. to Assign", '<>0');        if ItemChargeAssignmentSales.FindSet() then            repeat                QtyToHandle := ItemChargeAssignmentSales."Qty. to Handle";                ItemChargeAssignmentSales.Validate("Qty. to Assign",                  TempSalesLine."Qty. to Invoice" * Round(ItemChargeAssignmentSales."Qty. to Assign" / TempSalesLine."Qty. to Assign",                    UOMMgt.QtyRndPrecision()));                if QtyToHandle = 0 then                    ItemChargeAssignmentSales.Validate("Qty. to Handle", 0);                ItemChargeAssignmentSales.Modify();            until ItemChargeAssignmentSales.Next() = 0;        TempSalesLine.CalcFields("Qty. to Assign");        Delta := TempSalesLine."Qty. to Invoice" - TempSalesLine."Qty. to Assign";        if Delta <> 0 then begin            QtyToHandle := ItemChargeAssignmentSales."Qty. to Handle";            ItemChargeAssignmentSales.Validate("Qty. to Assign", ItemChargeAssignmentSales."Qty. to Assign" + Delta);            if QtyToHandle = 0 then                ItemChargeAssignmentSales.Validate("Qty. to Handle", 0);            ItemChargeAssignmentSales.Modify();        end;    end;    local procedure ClearItemChargeAssgntFilter()    begin        TempItemChargeAssgntSales.SetRange("Document Line No.");        TempItemChargeAssgntSales.SetRange("Applies-to Doc. Type");        TempItemChargeAssgntSales.SetRange("Applies-to Doc. No.");        TempItemChargeAssgntSales.SetRange("Applies-to Doc. Line No.");        TempItemChargeAssgntSales.MarkedOnly(false);    end;    local procedure GetItemChargeLine(SalesHeader: Record "Sales Header"; var ItemChargeSalesLine: Record "Sales Line")    var        SalesShptLine: Record "Sales Shipment Line";        ReturnReceiptLine: Record "Return Receipt Line";        QtyShippedNotInvd: Decimal;        QtyReceivedNotInvd: Decimal;    begin        if (ItemChargeSalesLine."Document Type" <> TempItemChargeAssgntSales."Document Type") or            (ItemChargeSalesLine."Document No." <> TempItemChargeAssgntSales."Document No.") or            (ItemChargeSalesLine."Line No." <> TempItemChargeAssgntSales."Document Line No.")        then begin            ItemChargeSalesLine.Get(TempItemChargeAssgntSales."Document Type", TempItemChargeAssgntSales."Document No.", TempItemChargeAssgntSales."Document Line No.");            if not SalesHeader.Ship then                ItemChargeSalesLine."Qty. to Ship" := 0;            if not SalesHeader.Receive then                ItemChargeSalesLine."Return Qty. to Receive" := 0;            if ItemChargeSalesLine."Shipment No." <> '' then begin                SalesShptLine.Get(ItemChargeSalesLine."Shipment No.", ItemChargeSalesLine."Shipment Line No.");                QtyShippedNotInvd := TempItemChargeAssgntSales."Qty. to Handle" - TempItemChargeAssgntSales."Qty. Assigned";            end else                QtyShippedNotInvd := ItemChargeSalesLine."Quantity Shipped";            if ItemChargeSalesLine."Return Receipt No." <> '' then begin                ReturnReceiptLine.Get(ItemChargeSalesLine."Return Receipt No.", ItemChargeSalesLine."Return Receipt Line No.");                QtyReceivedNotInvd := TempItemChargeAssgntSales."Qty. to Handle" - TempItemChargeAssgntSales."Qty. Assigned";            end else                QtyReceivedNotInvd := ItemChargeSalesLine."Return Qty. Received";            if Abs(ItemChargeSalesLine."Qty. to Invoice") >               Abs(QtyShippedNotInvd + ItemChargeSalesLine."Qty. to Ship" +                 QtyReceivedNotInvd + ItemChargeSalesLine."Return Qty. to Receive" -                 ItemChargeSalesLine."Quantity Invoiced")            then                ItemChargeSalesLine."Qty. to Invoice" :=                  QtyShippedNotInvd + ItemChargeSalesLine."Qty. to Ship" +                  QtyReceivedNotInvd + ItemChargeSalesLine."Return Qty. to Receive" -                  ItemChargeSalesLine."Quantity Invoiced";        end;    end;    local procedure CalcQtyToInvoice(QtyToHandle: Decimal; QtyToInvoice: Decimal): Decimal    begin        if Abs(QtyToHandle) > Abs(QtyToInvoice) then            exit(-QtyToHandle);        exit(-QtyToInvoice);    end;    local procedure CheckWarehouse(var TempItemSalesLine: Record "Sales Line" temporary)    var        ShowError: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckWarehouse(TempItemSalesLine, IsHandled);        if IsHandled then            exit;        TempItemSalesLine.SetRange(Type, TempItemSalesLine.Type::Item);        TempItemSalesLine.SetRange("Drop Shipment", false);        if TempItemSalesLine.FindSet() then            repeat                if TempItemSalesLine.IsInventoriableItem() then begin                    GetLocation(TempItemSalesLine."Location Code");                    case TempItemSalesLine."Document Type" of                        TempItemSalesLine."Document Type"::Order:                            if ((Location."Require Receive" or Location."Require Put-away") and (TempItemSalesLine.Quantity < 0)) or                               ((Location."Require Shipment" or Location."Require Pick") and (TempItemSalesLine.Quantity >= 0))                            then                                ShowError := GetShowErrorOnWarehouseCheck(TempItemSalesLine, Location);                        TempItemSalesLine."Document Type"::"Return Order":                            if ((Location."Require Receive" or Location."Require Put-away") and (TempItemSalesLine.Quantity >= 0)) or                               ((Location."Require Shipment" or Location."Require Pick") and (TempItemSalesLine.Quantity < 0))                            then                                ShowError := GetShowErrorOnWarehouseCheck(TempItemSalesLine, Location);                        TempItemSalesLine."Document Type"::Invoice, TempItemSalesLine."Document Type"::"Credit Memo":                            if Location."Directed Put-away and Pick" then                                Location.TestField("Adjustment Bin Code");                    end;                    if ShowError then                        Error(                          WarehouseRequiredErr,                          TempItemSalesLine.FieldCaption("Document Type"), TempItemSalesLine."Document Type",                          TempItemSalesLine.FieldCaption("Document No."), TempItemSalesLine."Document No.",                          TempItemSalesLine.FieldCaption("Line No."), TempItemSalesLine."Line No.");                end;            until TempItemSalesLine.Next() = 0;    end;    local procedure GetShowErrorOnWarehouseCheck(var SalesLine: Record "Sales Line"; Location: Record Location) ShowError: Boolean;    var        WhseValidateSourceLine: Codeunit "Whse. Validate Source Line";    begin        if Location."Directed Put-away and Pick" then            ShowError := true        else            if WhseValidateSourceLine.WhseLinesExist(                 DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(),                 SalesLine."Document No.", SalesLine."Line No.", 0, SalesLine.Quantity)            then begin                ShowError := true;                OnAfterWhseLinesExist(WhseValidateSourceLine, SalesLine, ShowError);            end;    end;    /// <summary>    /// Creates a Warehouse Journal Line for the specified sales line.    /// </summary>    /// <remarks>    /// Error can be raised if the Adjustment Bin of the Location has Movement Block.    /// </remarks>    /// <param name="ItemJnlLine">The Item Journal Line to create the Warehouse Journal Line for.</param>    /// <param name="SalesLine">The sales line to create the Warehouse Journal Line for.</param>    /// <param name="TempWhseJnlLine">Return Variable: The created Warehouse Journal Line.</param>    procedure CreateWhseJnlLine(ItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary)    var        WhseMgt: Codeunit "Whse. Management";        WMSMgt: Codeunit "WMS Management";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreateWhseJnlLine(ItemJnlLine, IsHandled);        if IsHandled then            exit;        WMSMgt.CheckAdjmtBin(Location, ItemJnlLine.Quantity, true);        WMSMgt.CreateWhseJnlLine(ItemJnlLine, 0, TempWhseJnlLine, false);        TempWhseJnlLine."Source Type" := DATABASE::"Sales Line";        TempWhseJnlLine."Source Subtype" := SalesLine."Document Type".AsInteger();        TempWhseJnlLine."Source Code" := SrcCode;        TempWhseJnlLine."Source Document" := WhseMgt.GetWhseJnlSourceDocument(TempWhseJnlLine."Source Type", TempWhseJnlLine."Source Subtype");        TempWhseJnlLine."Source No." := SalesLine."Document No.";        TempWhseJnlLine."Source Line No." := SalesLine."Line No.";        case SalesLine."Document Type" of            SalesLine."Document Type"::Order:                TempWhseJnlLine."Reference Document" :=                    TempWhseJnlLine."Reference Document"::"Posted Shipment";            SalesLine."Document Type"::Invoice:                TempWhseJnlLine."Reference Document" :=                    TempWhseJnlLine."Reference Document"::"Posted S. Inv.";            SalesLine."Document Type"::"Credit Memo":                TempWhseJnlLine."Reference Document" :=                    TempWhseJnlLine."Reference Document"::"Posted S. Cr. Memo";            SalesLine."Document Type"::"Return Order":                TempWhseJnlLine."Reference Document" :=                    TempWhseJnlLine."Reference Document"::"Posted Rtrn. Rcpt.";        end;        TempWhseJnlLine."Reference No." := ItemJnlLine."Document No.";        OnAfterCreateWhseJnlLine(SalesLine, TempWhseJnlLine);    end;    /// <summary>    /// Checks if warehouse handling (warehouse shipment or receipt) is required for the specified sales line.    /// Warehouse handling is relevant for sales lines for inventoriable item. Warehouse setup or location (if specified) determines if Warehouse Handling is required.    /// Drop shipments do not require Warehouse Handling.    /// </summary>    /// <param name="SalesLine">The sales line to check.</param>    /// <returns>Returns true if Warehouse Handling is required, otherwise false.</returns>    procedure WhseHandlingRequiredExternal(SalesLine: Record "Sales Line"): Boolean    begin        exit(WhseHandlingRequired(SalesLine));    end;    local procedure WhseHandlingRequired(SalesLine: Record "Sales Line") Required: Boolean    var        WhseSetup: Record "Warehouse Setup";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeWhseHandlingRequired(SalesLine, Required, IsHandled);        if IsHandled then            exit(Required);        if SalesLine.IsInventoriableItem() and (not SalesLine."Drop Shipment") then begin            if SalesLine."Location Code" = '' then begin                WhseSetup.Get();                if SalesLine."Document Type" = SalesLine."Document Type"::"Return Order" then                    exit(WhseSetup."Require Receive");                exit(WhseSetup."Require Shipment");            end;            GetLocation(SalesLine."Location Code");            if SalesLine."Document Type" = SalesLine."Document Type"::"Return Order" then                exit(Location."Require Receive");            exit(Location."Require Shipment");        end;        exit(false);    end;    local procedure GetLocation(LocationCode: Code[10])    begin        if LocationCode = '' then            Location.GetLocationSetup(LocationCode, Location)        else            if Location.Code <> LocationCode then                Location.Get(LocationCode);    end;    local procedure InsertShptEntryRelation(SalesHeader: Record "Sales Header"; var SalesShptLine: Record "Sales Shipment Line") ItemShptEntryNo: Integer    var        ItemEntryRelation: Record "Item Entry Relation";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertShptEntryRelation(SalesHeader, SalesShptLine, ItemShptEntryNo, IsHandled);        if IsHandled then            exit(ItemShptEntryNo);        TempHandlingSpecification.CopySpecification(TempTrackingSpecificationInv);        TempHandlingSpecification.CopySpecification(TempATOTrackingSpecification);        TempHandlingSpecification.Reset();        if TempHandlingSpecification.FindSet() then begin            repeat                ItemEntryRelation.InitFromTrackingSpec(TempHandlingSpecification);                ItemEntryRelation.TransferFieldsSalesShptLine(SalesShptLine);                ItemEntryRelation.Insert();                OnInsertShptEntryRelationOnAfterItemEntryRelationInsert(SalesShptLine, ItemEntryRelation, xSalesLine);            until TempHandlingSpecification.Next() = 0;            OnInsertShptEntryRelationOnBeforeDeleteTempHandlingSpecification(TempHandlingSpecification);            TempHandlingSpecification.DeleteAll();            exit(0);        end;        exit(ItemLedgShptEntryNo);    end;    local procedure InsertReturnEntryRelation(var ReturnRcptLine: Record "Return Receipt Line") EntryNo: Integer    var        ItemEntryRelation: Record "Item Entry Relation";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertReturnEntryRelation(ReturnRcptLine, EntryNo, IsHandled);        if IsHandled then            exit;        TempHandlingSpecification.CopySpecification(TempTrackingSpecificationInv);        TempHandlingSpecification.CopySpecification(TempATOTrackingSpecification);        TempHandlingSpecification.Reset();        if TempHandlingSpecification.FindSet() then begin            repeat                ItemEntryRelation.InitFromTrackingSpec(TempHandlingSpecification);                ItemEntryRelation.TransferFieldsReturnRcptLine(ReturnRcptLine);                ItemEntryRelation.Insert();            until TempHandlingSpecification.Next() = 0;            TempHandlingSpecification.DeleteAll();            exit(0);        end;        exit(ItemLedgShptEntryNo);    end;    /// <summary>    /// Checks if the sales line is posted with Item Tracking, then tracked quantity must be equal to posted quantity.    /// </summary>    /// <param name="SalesHeader">The sales header of the document. Only Orders and Return Orders are relevant.</param>    /// <param name="TempItemSalesLine">Temp sales lines to Check.</param>    procedure CheckTrackingSpecification(SalesHeader: Record "Sales Header"; var TempItemSalesLine: Record "Sales Line" temporary)    var        ReservationEntry: Record "Reservation Entry";        ItemTrackingCode: Record "Item Tracking Code";        ItemTrackingSetup: Record "Item Tracking Setup";        ItemJnlLine: Record "Item Journal Line";        CreateReservEntry: Codeunit "Create Reserv. Entry";        ItemTrackingManagement: Codeunit "Item Tracking Management";        ErrorFieldCaption: Text;        SignFactor: Integer;        SalesLineQtyToHandle: Decimal;        TrackingQtyToHandle: Decimal;        Inbound: Boolean;        CheckSalesLine: Boolean;        IsHandled: Boolean;    begin        OnBeforeCheckTrackingSpecification(SalesHeader, TempItemSalesLine);        // if a SalesLine is posted with ItemTracking then tracked quantity must be equal to posted quantity        if not (SalesHeader."Document Type" in                [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"])        then            exit;        TrackingQtyToHandle := 0;        TempItemSalesLine.SetRange(Type, TempItemSalesLine.Type::Item);        if SalesHeader.Ship then begin            TempItemSalesLine.SetFilter("Quantity Shipped", '<>%1', 0);            ErrorFieldCaption := TempItemSalesLine.FieldCaption("Qty. to Ship");        end else begin            TempItemSalesLine.SetFilter("Return Qty. Received", '<>%1', 0);            ErrorFieldCaption := TempItemSalesLine.FieldCaption("Return Qty. to Receive");        end;        if TempItemSalesLine.FindSet() then begin            ReservationEntry."Source Type" := DATABASE::"Sales Line";            ReservationEntry."Source Subtype" := SalesHeader."Document Type".AsInteger();            SignFactor := CreateReservEntry.SignFactor(ReservationEntry);            repeat                // Only Item where no SerialNo or LotNo is required                TempItemSalesLine.GetItem(Item);                if Item."Item Tracking Code" <> '' then begin                    Inbound := (TempItemSalesLine.Quantity * SignFactor) > 0;                    ItemTrackingCode.Code := Item."Item Tracking Code";                    IsHandled := false;                    OnCheckTrackingSpecificationOnBeforeGetItemTrackingSettings(TempItemSalesLine, ItemTrackingSetup, IsHandled);                    if not IsHandled then                        ItemTrackingManagement.GetItemTrackingSetup(                            ItemTrackingCode, ItemJnlLine."Entry Type"::Sale, Inbound, ItemTrackingSetup);                    CheckSalesLine := not ItemTrackingSetup.TrackingRequired();                    if CheckSalesLine then                        CheckSalesLine := CheckTrackingExists(TempItemSalesLine);                end else                    CheckSalesLine := false;                TrackingQtyToHandle := 0;                if CheckSalesLine then begin                    TrackingQtyToHandle := GetTrackingQuantities(TempItemSalesLine) * SignFactor;                    if SalesHeader.Ship then                        SalesLineQtyToHandle := TempItemSalesLine."Qty. to Ship (Base)"                    else                        SalesLineQtyToHandle := TempItemSalesLine."Return Qty. to Receive (Base)";                    if TrackingQtyToHandle <> SalesLineQtyToHandle then                        Error(ItemTrackQuantityMismatchErr, ErrorFieldCaption, TempItemSalesLine."No.");                end;                OnCheckTrackingSpecificationOnAfterTempItemSalesLineLoop(TempItemSalesLine);            until TempItemSalesLine.Next() = 0;        end;        if SalesHeader.Ship then            TempItemSalesLine.SetRange("Quantity Shipped")        else            TempItemSalesLine.SetRange("Return Qty. Received");    end;    local procedure CheckTrackingExists(SalesLine: Record "Sales Line"): Boolean    begin        exit(          ItemTrackingMgt.ItemTrackingExistsOnDocumentLine(            DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No."));    end;    local procedure GetTrackingQuantities(SalesLine: Record "Sales Line"): Decimal    begin        exit(          ItemTrackingMgt.CalcQtyToHandleForTrackedQtyOnDocumentLine(            DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No."));    end;    local procedure SaveInvoiceSpecification(var TempInvoicingSpecification: Record "Tracking Specification" temporary)    begin        TempInvoicingSpecification.Reset();        if TempInvoicingSpecification.FindSet() then begin            repeat                TempInvoicingSpecification."Quantity Invoiced (Base)" += TempInvoicingSpecification."Quantity actual Handled (Base)";                TempInvoicingSpecification."Quantity actual Handled (Base)" := 0;                OnSaveInvoiceSpecificationOnBeforeAssignTempInvoicingSpecification(TempInvoicingSpecification);                TempTrackingSpecification := TempInvoicingSpecification;                TempTrackingSpecification."Buffer Status" := TempTrackingSpecification."Buffer Status"::MODIFY;                if not TempTrackingSpecification.Insert() then begin                    TempTrackingSpecification.Get(TempInvoicingSpecification."Entry No.");                    TempTrackingSpecification."Qty. to Invoice (Base)" += TempInvoicingSpecification."Qty. to Invoice (Base)";                    TempTrackingSpecification."Quantity Invoiced (Base)" += TempInvoicingSpecification."Qty. to Invoice (Base)";                    TempTrackingSpecification."Qty. to Invoice" += TempInvoicingSpecification."Qty. to Invoice";                    TempTrackingSpecification.Modify();                end;                OnSaveInvoiceSpecificationOnAfterUpdateTempTrackingSpecification(TempTrackingSpecification, TempInvoicingSpecification);            until TempInvoicingSpecification.Next() = 0;            TempInvoicingSpecification.DeleteAll();        end;    end;    local procedure InsertTrackingSpecification(SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertTrackingSpecification(SalesHeader, TempTrackingSpecification, IsHandled);        if IsHandled then            exit;        TempTrackingSpecification.Reset();        if not TempTrackingSpecification.IsEmpty() then begin            TempTrackingSpecification.InsertSpecification();            SalesLineReserve.UpdateItemTrackingAfterPosting(SalesHeader);        end;    end;    /// <summary>    /// Stores Value Entry Relations from a global temp table TempValueEntryRelation to the Value Entry Relation table.    /// The global temp table is then cleared.    /// </summary>    procedure InsertValueEntryRelation()    var        ValueEntryRelation: Record "Value Entry Relation";    begin        TempValueEntryRelation.Reset();        if TempValueEntryRelation.FindSet() then begin            repeat                ValueEntryRelation := TempValueEntryRelation;                ValueEntryRelation.Insert();            until TempValueEntryRelation.Next() = 0;            TempValueEntryRelation.DeleteAll();        end;    end;    /// <summary>    /// Posts an item charge to the specified item ledger entry.    /// </summary>    /// <param name="SalesHeader">The sales header record.</param>    /// <param name="SalesLine">The sales line with the item charge.</param>    /// <param name="ItemLedgEntryNo">The item ledger entry number to apply the charge to.</param>    /// <param name="QuantityBase">The quantity in base unit of measure.</param>    /// <param name="AmountToAssign">The amount to assign.</param>    /// <param name="QtyToAssign">The quantity to assign.</param>    procedure PostItemCharge(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; ItemLedgEntryNo: Integer; QuantityBase: Decimal; AmountToAssign: Decimal; QtyToAssign: Decimal)    var        DummyTrackingSpecification: Record "Tracking Specification";        SalesLineToPost: Record "Sales Line";    begin        OnBeforePostItemCharge(SalesHeader, SalesLine, TempItemChargeAssgntSales, ItemLedgEntryNo);        SalesLineToPost := SalesLine;        SalesLineToPost."No." := TempItemChargeAssgntSales."Item No.";        SalesLineToPost."Appl.-to Item Entry" := ItemLedgEntryNo;        if not (TempItemChargeAssgntSales."Document Type" in [TempItemChargeAssgntSales."Document Type"::"Return Order", TempItemChargeAssgntSales."Document Type"::"Credit Memo"]) then            SalesLineToPost.Amount := -AmountToAssign        else            SalesLineToPost.Amount := AmountToAssign;        if SalesLineToPost."Currency Code" <> '' then            SalesLineToPost."Unit Cost" := Round(                SalesLineToPost.Amount / QuantityBase, Currency."Unit-Amount Rounding Precision")        else            SalesLineToPost."Unit Cost" := Round(                SalesLineToPost.Amount / QuantityBase, GLSetup."Unit-Amount Rounding Precision");        TotalChargeAmt := TotalChargeAmt + SalesLineToPost.Amount;        OnPostItemChargeOnAfterCalcTotalChargeAmt(SalesLineToPost, QtyToAssign, SalesLine, xSalesLine);        if SalesHeader."Currency Code" <> '' then            SalesLineToPost.Amount :=              CurrExchRate.ExchangeAmtFCYToLCY(                SalesHeader.GetUseDate(), SalesHeader."Currency Code", TotalChargeAmt, SalesHeader."Currency Factor");        SalesLineToPost."Inv. Discount Amount" := Round(            SalesLine."Inv. Discount Amount" / SalesLine.Quantity * QtyToAssign,            GLSetup."Amount Rounding Precision");        SalesLineToPost."Line Discount Amount" := Round(            SalesLine."Line Discount Amount" / SalesLine.Quantity * QtyToAssign,            GLSetup."Amount Rounding Precision");        SalesLineToPost."Line Amount" := Round(            SalesLine."Line Amount" / SalesLine.Quantity * QtyToAssign,            GLSetup."Amount Rounding Precision");        SalesLine."Inv. Discount Amount" := SalesLine."Inv. Discount Amount" - SalesLineToPost."Inv. Discount Amount";        SalesLine."Line Discount Amount" := SalesLine."Line Discount Amount" - SalesLineToPost."Line Discount Amount";        SalesLine."Line Amount" := SalesLine."Line Amount" - SalesLineToPost."Line Amount";        SalesLine.Quantity := SalesLine.Quantity - QtyToAssign;        SalesLineToPost.Amount := Round(SalesLineToPost.Amount, GLSetup."Amount Rounding Precision") - TotalChargeAmtLCY;        if SalesHeader."Currency Code" <> '' then            TotalChargeAmtLCY := TotalChargeAmtLCY + SalesLineToPost.Amount;        SalesLineToPost."Unit Cost (LCY)" := Round(            SalesLineToPost.Amount / QuantityBase, GLSetup."Unit-Amount Rounding Precision");        UpdateSalesLineDimSetIDFromAppliedEntry(SalesLineToPost, SalesLine);        SalesLineToPost."Line No." := TempItemChargeAssgntSales."Document Line No.";        OnPostItemChargeOnBeforePostItemJnlLine(SalesLineToPost, SalesLine, QtyToAssign, TempItemChargeAssgntSales);        PostItemJnlLine(          SalesHeader, SalesLineToPost, 0, 0, -QuantityBase, -QuantityBase,          SalesLineToPost."Appl.-to Item Entry", TempItemChargeAssgntSales."Item Charge No.", DummyTrackingSpecification, false);        OnPostItemChargeOnAfterPostItemJnlLine(SalesHeader, SalesLineToPost);        OnAfterPostItemCharge(SalesHeader, SalesLine, TempItemChargeAssgntSales, ItemLedgEntryNo);    end;    local procedure SaveTempWhseSplitSpec(var SalesLine3: Record "Sales Line"; var TempSrcTrackingSpec: Record "Tracking Specification" temporary)    begin        TempWhseSplitSpecification.Reset();        TempWhseSplitSpecification.DeleteAll();        if TempSrcTrackingSpec.FindSet() then            repeat                TempWhseSplitSpecification := TempSrcTrackingSpec;                TempWhseSplitSpecification.SetSource(                  DATABASE::"Sales Line", SalesLine3."Document Type".AsInteger(), SalesLine3."Document No.", SalesLine3."Line No.", '', 0);                TempWhseSplitSpecification.Insert();            until TempSrcTrackingSpec.Next() = 0;    end;    /// <summary>    /// Transfers reservation entries from a sales line to an item journal line.    /// </summary>    /// <param name="SalesOrderLine">The sales order line with reservations.</param>    /// <param name="ItemJnlLine">The item journal line to transfer reservations to.</param>    /// <param name="QtyToBeShippedBase">The base quantity to be shipped.</param>    /// <param name="TempTrackingSpecification2">Temporary tracking specifications.</param>    /// <param name="CheckApplFromItemEntry">Returns whether to check application from item entry.</param>    procedure TransferReservToItemJnlLine(var SalesOrderLine: Record "Sales Line"; var ItemJnlLine: Record "Item Journal Line"; QtyToBeShippedBase: Decimal; var TempTrackingSpecification2: Record "Tracking Specification" temporary; var CheckApplFromItemEntry: Boolean)    var        RemainingQuantity: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTransferReservToItemJnlLine(SalesOrderLine, QtyToBeShippedBase, IsHandled);        if IsHandled then            exit;        // Handle Item Tracking and reservations, also on drop shipment        if QtyToBeShippedBase = 0 then            exit;        Clear(SalesLineReserve);        if not SalesOrderLine."Drop Shipment" then            SalesLineReserve.TransferSalesLineToItemJnlLine(              SalesOrderLine, ItemJnlLine, QtyToBeShippedBase, CheckApplFromItemEntry, false)        else begin            SalesLineReserve.SetApplySpecificItemTracking(true);            TempTrackingSpecification2.Reset();            TempTrackingSpecification2.SetSourceFilter(              DATABASE::"Purchase Line", 1, SalesOrderLine."Purchase Order No.", SalesOrderLine."Purch. Order Line No.", false);            TempTrackingSpecification2.SetSourceFilter('', 0);            if TempTrackingSpecification2.IsEmpty() then                SalesLineReserve.TransferSalesLineToItemJnlLine(                  SalesOrderLine, ItemJnlLine, QtyToBeShippedBase, CheckApplFromItemEntry, false)            else begin                SalesLineReserve.SetOverruleItemTracking(true);                SalesLineReserve.SetItemTrkgAlreadyOverruled(ItemTrkgAlreadyOverruled);                TempTrackingSpecification2.FindSet();                if TempTrackingSpecification2."Quantity (Base)" / QtyToBeShippedBase < 0 then                    Error(ItemTrackingWrongSignErr);                repeat                    ItemJnlLine.CopyTrackingFromSpec(TempTrackingSpecification2);                    ItemJnlLine."Applies-to Entry" := TempTrackingSpecification2."Item Ledger Entry No.";                    RemainingQuantity :=                      SalesLineReserve.TransferSalesLineToItemJnlLine(                        SalesOrderLine, ItemJnlLine, TempTrackingSpecification2."Quantity (Base)", CheckApplFromItemEntry, false);                    if RemainingQuantity <> 0 then                        Error(ItemTrackingMismatchErr);                until TempTrackingSpecification2.Next() = 0;                ItemJnlLine.ClearTracking();                ItemJnlLine."Applies-to Entry" := 0;            end;        end;    end;    /// <summary>    /// Transfers reservation entries from a purchase line to an item journal line for drop shipments.    /// </summary>    /// <param name="PurchOrderLine">The purchase order line with reservations.</param>    /// <param name="ItemJnlLine">The item journal line to transfer reservations to.</param>    /// <param name="SalesLine">The related sales line.</param>    /// <param name="QtyToBeShippedBase">The base quantity to be shipped.</param>    procedure TransferReservFromPurchLine(var PurchOrderLine: Record "Purchase Line"; var ItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; QtyToBeShippedBase: Decimal)    var        ReservEntry: Record "Reservation Entry";        TempTrackingSpecification2: Record "Tracking Specification" temporary;        PurchLineReserve: Codeunit "Purch. Line-Reserve";        RemainingQuantity: Decimal;        CheckApplToItemEntry: Boolean;    begin        // Handle Item Tracking on Drop Shipment        ItemTrkgAlreadyOverruled := false;        if QtyToBeShippedBase = 0 then            exit;        ReservEntry.SetSourceFilter(          DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.", true);        ReservEntry.SetSourceFilter('', 0);        ReservEntry.SetFilter("Qty. to Handle (Base)", '<>0');        if not ReservEntry.IsEmpty() then            ItemTrackingMgt.SumUpItemTracking(ReservEntry, TempTrackingSpecification2, false, true);        TempTrackingSpecification2.SetFilter("Qty. to Handle (Base)", '<>0');        if TempTrackingSpecification2.IsEmpty() then begin            SalesLineReserve.SetApplySpecificItemTracking(true);            PurchLineReserve.TransferPurchLineToItemJnlLine(              PurchOrderLine, ItemJnlLine, QtyToBeShippedBase, CheckApplToItemEntry)        end else begin            PurchLineReserve.SetOverruleItemTracking(true);            ItemTrkgAlreadyOverruled := true;            TempTrackingSpecification2.FindSet();            if -TempTrackingSpecification2."Quantity (Base)" / QtyToBeShippedBase < 0 then                Error(ItemTrackingWrongSignErr);            if PurchOrderLine.ReservEntryExist() then                repeat                    ItemJnlLine.CopyTrackingFromSpec(TempTrackingSpecification2);                    RemainingQuantity :=                      PurchLineReserve.TransferPurchLineToItemJnlLine(                        PurchOrderLine, ItemJnlLine,                        -TempTrackingSpecification2."Qty. to Handle (Base)", CheckApplToItemEntry);                    if RemainingQuantity <> 0 then                        Error(ItemTrackingMismatchErr);                until TempTrackingSpecification2.Next() = 0;            ItemJnlLine.ClearTracking();            ItemJnlLine."Applies-to Entry" := 0;        end;    end;    /// <summary>    /// Sets the incoming Warehouse Receipt Header record to the global variable and inserts it to the global Temp table for Warehouse Receipt Header.    /// </summary>    /// <param name="WhseRcptHeader2"></param>    procedure SetWhseRcptHeader(var WhseRcptHeader2: Record "Warehouse Receipt Header")    begin        WhseRcptHeader := WhseRcptHeader2;        TempWhseRcptHeader := WhseRcptHeader;        TempWhseRcptHeader.Insert();    end;    /// <summary>    /// Sets the incoming Warehouse Shipment Header record to the global variable and inserts it to the global Temp table for Warehouse Shipment Header.    /// </summary>    /// <param name="WhseShptHeader2"></param>    procedure SetWhseShptHeader(var WhseShptHeader2: Record "Warehouse Shipment Header")    begin        WhseShptHeader := WhseShptHeader2;        TempWhseShptHeader := WhseShptHeader;        TempWhseShptHeader.Insert();    end;    /// <summary>    /// Creates Prepayment lines for the specified sales header and adds them to the global sales line temp table.    /// </summary>    /// <remarks>    /// If CompleteFunctionality is true, then the following is additionally done:    ///     - Prepayment Amount to deduct is tested using information from Sales Shipment Lines.    ///     - Validates Qty. to Invoice with Qty. Shipped Not Invoiced if the Qty. to Invoice is larger than shipped Qty.    ///     - Checks that Prepayment Amount to deduct is not greater than the remaining amount to invoice for each line    ///     - Prepayment Line Type is Validated (otherwise it's only assigned).    /// If "Compress Prepayments" is enabled for the sales header, only one prepayment line is created.    /// </remarks>    /// <param name="SalesHeader">The sales header to create the prepayment lines for.</param>    /// <param name="CompleteFunctionality">Specifies if the complete functionality of the procedure should be used.</param>    procedure CreatePrepaymentLines(SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean)    var        GLAcc: Record "G/L Account";        TempSalesLine: Record "Sales Line" temporary;        TempExtTextLine: Record "Extended Text Line" temporary;        GenPostingSetup: Record "General Posting Setup";        TempPrepmtSalesLine: Record "Sales Line" temporary;        TransferExtText: Codeunit "Transfer Extended Text";        NextLineNo: Integer;        Fraction: Decimal;        VATDifference: Decimal;        TempLineFound: Boolean;        PrepmtAmtToDeduct: Decimal;        IsHandled: Boolean;        ShouldValidateQtyToInvoice: Boolean;        ShouldTestGetShipmentPPmtAmtToDeduct: Boolean;    begin        IsHandled := false;        OnBeforeCreatePrepaymentLines(SalesHeader, TempPrepmtSalesLine, CompleteFunctionality, IsHandled, TempSalesLineGlobal);        if IsHandled then            exit;        GetGLSetup();        FillTempLines(SalesHeader, TempSalesLineGlobal);        ResetTempLines(TempSalesLine);        if not TempSalesLine.FindLast() then            exit;        NextLineNo := TempSalesLine."Line No." + 10000;        TempSalesLine.SetFilter(Quantity, '>0');        TempSalesLine.SetFilter("Qty. to Invoice", '>0');        OnCreatePrepaymentLinesOnAfterTempSalesLineSetFilters(TempSalesLine, SalesHeader, TempPrepmtSalesLine, NextLineNo);        TempPrepmtSalesLine.SetHasBeenShown();        // Get all sales lines        if TempSalesLine.FindSet() then begin            ShouldTestGetShipmentPPmtAmtToDeduct := CompleteFunctionality and (TempSalesLine."Document Type" = TempSalesLine."Document Type"::Invoice);            OnCreatePrepaymentLinesOnBeforeShouldTestGetShipmentPPmtAmtToDeduct(SalesHeader, CompleteFunctionality, ShouldTestGetShipmentPPmtAmtToDeduct);            if ShouldTestGetShipmentPPmtAmtToDeduct then                TestGetShipmentPPmtAmtToDeduct();            repeat                if CompleteFunctionality then begin                    ShouldValidateQtyToInvoice := SalesHeader."Document Type" <> SalesHeader."Document Type"::Invoice;                    OnCreatePrepaymentLinesOnBeforeValidateQtyToInvoice(SalesHeader, ShouldValidateQtyToInvoice, TempSalesLine);                    if ShouldValidateQtyToInvoice then begin                        if not SalesHeader.Ship and (TempSalesLine."Qty. to Invoice" = TempSalesLine.Quantity - TempSalesLine."Quantity Invoiced") then                            if TempSalesLine."Qty. Shipped Not Invoiced" < TempSalesLine."Qty. to Invoice" then                                TempSalesLine.Validate("Qty. to Invoice", TempSalesLine."Qty. Shipped Not Invoiced");                        Fraction := (TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced") / TempSalesLine.Quantity;                        CheckPrepmtAmtToDeduct(SalesHeader, TempSalesLine, Fraction);                    end;                end;                if TempSalesLine."Prepmt Amt to Deduct" <> 0 then begin                    if (TempSalesLine."Gen. Bus. Posting Group" <> GenPostingSetup."Gen. Bus. Posting Group") or                       (TempSalesLine."Gen. Prod. Posting Group" <> GenPostingSetup."Gen. Prod. Posting Group")                    then                        GetGeneralPostingSetup(GenPostingSetup, TempSalesLine);                    IsHandled := false;                    OnCreatePrepaymentLinesOnBeforeGetSalesPrepmtAccount(GLAcc, TempSalesLine, SalesHeader, GenPostingSetup, CompleteFunctionality, IsHandled);                    if not IsHandled then                        GLAcc.Get(GenPostingSetup.GetSalesPrepmtAccount());                    OnCreatePrepaymentLinesOnAfterGetSalesPrepmtAccount(GLAcc, TempSalesLine, SalesHeader, CompleteFunctionality);                    TempLineFound := false;                    if SalesHeader."Compress Prepayment" then begin                        TempPrepmtSalesLine.SetRange("No.", GLAcc."No.");                        TempPrepmtSalesLine.SetRange("Dimension Set ID", TempSalesLine."Dimension Set ID");                        OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineSetFilters(TempPrepmtSalesLine, TempSalesLine);                        TempLineFound := TempPrepmtSalesLine.FindFirst();                    end;                    if TempLineFound then begin                        PrepmtAmtToDeduct :=                          TempPrepmtSalesLine."Prepmt Amt to Deduct" +                          InsertedPrepmtVATBaseToDeduct(                            SalesHeader, TempSalesLine, TempPrepmtSalesLine."Line No.", TempPrepmtSalesLine."Unit Price");                        VATDifference := TempPrepmtSalesLine."VAT Difference";                        TempPrepmtSalesLine.Validate(                          "Unit Price", TempPrepmtSalesLine."Unit Price" + TempSalesLine."Prepmt Amt to Deduct");                        TempPrepmtSalesLine.Validate("VAT Difference", VATDifference - TempSalesLine."Prepmt VAT Diff. to Deduct");                        TempPrepmtSalesLine."Prepmt Amt to Deduct" := PrepmtAmtToDeduct;                        if TempSalesLine."Prepayment %" < TempPrepmtSalesLine."Prepayment %" then                            TempPrepmtSalesLine."Prepayment %" := TempSalesLine."Prepayment %";                        OnBeforeTempPrepmtSalesLineModify(TempPrepmtSalesLine, TempSalesLine, SalesHeader, CompleteFunctionality);                        TempPrepmtSalesLine.Modify();                        OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineModify(TempPrepmtSalesLine, TempSalesLine, SalesHeader);                    end else begin                        TempPrepmtSalesLine.Init();                        TempPrepmtSalesLine."Document Type" := SalesHeader."Document Type";                        TempPrepmtSalesLine."Document No." := SalesHeader."No.";                        TempPrepmtSalesLine."Line No." := 0;                        TempPrepmtSalesLine."System-Created Entry" := true;                        OnCreatePrepaymentLinesOnBeforeValidateType(TempPrepmtSalesLine, SalesHeader, TempSalesLine);                        if CompleteFunctionality then                            TempPrepmtSalesLine.Validate(Type, TempPrepmtSalesLine.Type::"G/L Account")                        else                            TempPrepmtSalesLine.Type := TempPrepmtSalesLine.Type::"G/L Account";                        // deduct from prepayment                        TempPrepmtSalesLine.Validate("No.", GLAcc."No.");                        TempPrepmtSalesLine.Validate(Quantity, -1);                        TempPrepmtSalesLine."Qty. to Ship" := TempPrepmtSalesLine.Quantity;                        TempPrepmtSalesLine."Qty. to Invoice" := TempPrepmtSalesLine.Quantity;                        OnCreatePrepaymentLinesOnBeforeInsertedPrepmtVATBaseToDeduct(TempPrepmtSalesLine, SalesHeader, TempSalesLine);                        PrepmtAmtToDeduct := InsertedPrepmtVATBaseToDeduct(SalesHeader, TempSalesLine, NextLineNo, 0);                        TempPrepmtSalesLine.Validate("Unit Price", TempSalesLine."Prepmt Amt to Deduct");                        TempPrepmtSalesLine.Validate("VAT Difference", -TempSalesLine."Prepmt VAT Diff. to Deduct");                        TempPrepmtSalesLine."Prepmt Amt to Deduct" := PrepmtAmtToDeduct;                        TempPrepmtSalesLine."Prepayment %" := TempSalesLine."Prepayment %";                        TempPrepmtSalesLine."Prepayment Line" := true;                        TempPrepmtSalesLine."Shortcut Dimension 1 Code" := TempSalesLine."Shortcut Dimension 1 Code";                        TempPrepmtSalesLine."Shortcut Dimension 2 Code" := TempSalesLine."Shortcut Dimension 2 Code";                        TempPrepmtSalesLine."Gen. Bus. Posting Group" := TempSalesLine."Gen. Bus. Posting Group";                        TempPrepmtSalesLine."Gen. Prod. Posting Group" := TempSalesLine."Gen. Prod. Posting Group";                        TempPrepmtSalesLine."Dimension Set ID" := TempSalesLine."Dimension Set ID";                        TempPrepmtSalesLine."Line No." := NextLineNo;                        NextLineNo := NextLineNo + 10000;                        OnBeforeTempPrepmtSalesLineInsert(TempPrepmtSalesLine, TempSalesLine, SalesHeader, CompleteFunctionality);                        TempPrepmtSalesLine.Insert();                        OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineInsert(TempPrepmtSalesLine, TempSalesLine, SalesHeader);                        IsHandled := false;                        OnBeforeCreatePrepaymentTextLines(TempPrepmtSalesLine, TempSalesLine, SalesHeader, CompleteFunctionality, IsHandled);                        if not IsHandled then                            TransferExtText.PrepmtGetAnyExtText(                                TempPrepmtSalesLine."No.", DATABASE::"Sales Invoice Line",                                SalesHeader."Document Date", SalesHeader."Language Code", TempExtTextLine);                        if TempExtTextLine.Find('-') then                            repeat                                TempPrepmtSalesLine.Init();                                TempPrepmtSalesLine.Description := TempExtTextLine.Text;                                TempPrepmtSalesLine."System-Created Entry" := true;                                TempPrepmtSalesLine."Prepayment Line" := true;                                TempPrepmtSalesLine."Line No." := NextLineNo;                                NextLineNo := NextLineNo + 10000;                                OnCreatePrepaymentLinesOnBeforeInsertTempLineForExtText(TempPrepmtSalesLine, TempSalesLine, TempExtTextLine, SalesHeader);                                TempPrepmtSalesLine.Insert();                            until TempExtTextLine.Next() = 0;                    end;                end;            until TempSalesLine.Next() = 0;            OnCreatePrepaymentLinesOnAfterProcessSalesLines(SalesHeader, TempPrepmtSalesLine, NextLineNo);        end;        DividePrepmtAmountLCY(TempPrepmtSalesLine, SalesHeader);        if TempPrepmtSalesLine.FindSet() then            repeat                TempSalesLineGlobal := TempPrepmtSalesLine;                TempSalesLineGlobal.Insert();            until TempPrepmtSalesLine.Next() = 0;    end;    /// <summary>    /// Checks that the Prepayment amount to deduct of the sales line is within limits    /// </summary>    /// <remarks>    /// First condition checks that the Prepayment amount to deduct is not greater than the amount being posted.    /// Second condition checks that the remaining Prepayment amount to deduct is not greater than the remaining amount to invoice.    /// </remarks>    /// <param name="SalesHeader">The sales header of the document being posted.</param>    /// <param name="TempSalesLine">The sales line to check.</param>    /// <param name="Fraction">The fraction of the sales line to be invoiced.</param>    procedure CheckPrepmtAmtToDeduct(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; Fraction: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckPrepmtAmtToDeduct(TempSalesLine, SalesHeader, IsHandled, Fraction);        if IsHandled then            exit;        if TempSalesLine."Prepayment %" <> 100 then            case true of                (TempSalesLine."Prepmt Amt to Deduct" <> 0) and              (TempSalesLine."Prepmt Amt to Deduct" > Round(Fraction * TempSalesLine."Line Amount", Currency."Amount Rounding Precision")):                    TempSalesLine.FieldError(                      TempSalesLine."Prepmt Amt to Deduct",                      StrSubstNo(CannotBeGreaterThanErr,                        Round(Fraction * TempSalesLine."Line Amount", Currency."Amount Rounding Precision")));                (TempSalesLine."Prepmt. Amt. Inv." <> 0) and              (Round((1 - Fraction) * TempSalesLine."Line Amount", Currency."Amount Rounding Precision") <               Round(                 Round(                   Round(TempSalesLine."Unit Price" * (TempSalesLine.Quantity - TempSalesLine."Quantity Invoiced" - TempSalesLine."Qty. to Invoice"),                     Currency."Amount Rounding Precision") *                   (1 - (TempSalesLine."Line Discount %" / 100)), Currency."Amount Rounding Precision") *                 TempSalesLine."Prepayment %" / 100, Currency."Amount Rounding Precision")):                    TempSalesLine.FieldError(                      TempSalesLine."Prepmt Amt to Deduct",                      StrSubstNo(CannotBeSmallerThanErr,                        Round(                          TempSalesLine."Prepmt. Amt. Inv." - TempSalesLine."Prepmt Amt Deducted" - (1 - Fraction) * TempSalesLine."Line Amount",                          Currency."Amount Rounding Precision")));            end;    end;    /// <summary>    /// Calculates the prepayment VAT Base amount to deduct and inserts a prepayment line for it in a global temp table TempPrepmtDeductLCYSalesLine.    /// </summary>    /// <param name="SalesHeader">The sales header of the document being posted.</param>    /// <param name="SalesLine">The sales line of the document for which the prepayment VAT Base amount is being calculated.</param>    /// <param name="PrepmtLineNo">The Line No. of the prepayment line to which this VAT Base Prepayment line is attached to.</param>    /// <param name="TotalPrepmtAmtToDeduct">The running total of the prepayment amount to deduct. Used when compressing prepayments to a single line.</param>    /// <returns>Prepayment VAT Base amount to deduct</returns>    procedure InsertedPrepmtVATBaseToDeduct(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; PrepmtLineNo: Integer; TotalPrepmtAmtToDeduct: Decimal): Decimal    var        PrepmtVATBaseToDeduct: Decimal;    begin        if SalesHeader."Prices Including VAT" then            PrepmtVATBaseToDeduct :=              Round(                (TotalPrepmtAmtToDeduct + SalesLine."Prepmt Amt to Deduct") / (1 + SalesLine.GetPrepaymentVATPct() / 100),                Currency."Amount Rounding Precision") -              Round(                TotalPrepmtAmtToDeduct / (1 + SalesLine.GetPrepaymentVATPct() / 100),                Currency."Amount Rounding Precision")        else            PrepmtVATBaseToDeduct := SalesLine."Prepmt Amt to Deduct";        TempPrepmtDeductLCYSalesLine := SalesLine;        if TempPrepmtDeductLCYSalesLine."Document Type" = TempPrepmtDeductLCYSalesLine."Document Type"::Order then            TempPrepmtDeductLCYSalesLine."Qty. to Invoice" := GetQtyToInvoice(SalesLine, SalesHeader.Ship)        else            GetLineDataFromOrder(TempPrepmtDeductLCYSalesLine);        if (TempPrepmtDeductLCYSalesLine."Prepmt Amt to Deduct" = 0) or (TempPrepmtDeductLCYSalesLine."Document Type" = TempPrepmtDeductLCYSalesLine."Document Type"::Invoice) then            TempPrepmtDeductLCYSalesLine.CalcPrepaymentToDeduct();        TempPrepmtDeductLCYSalesLine."Line Amount" := TempPrepmtDeductLCYSalesLine.GetLineAmountToHandleInclPrepmt(TempPrepmtDeductLCYSalesLine."Qty. to Invoice");        TempPrepmtDeductLCYSalesLine."Attached to Line No." := PrepmtLineNo;        TempPrepmtDeductLCYSalesLine."VAT Base Amount" := PrepmtVATBaseToDeduct;        TempPrepmtDeductLCYSalesLine.Insert();        OnAfterInsertedPrepmtVATBaseToDeduct(          SalesHeader, SalesLine, PrepmtLineNo, TotalPrepmtAmtToDeduct, TempPrepmtDeductLCYSalesLine, PrepmtVATBaseToDeduct);        exit(PrepmtVATBaseToDeduct);    end;    /// <summary>    /// Calculates the LCY Amount of Prepayment VAT Base Amount for each prepayment line and updates the global temp table TempPrepmtDeductLCYSalesLine with it.    /// </summary>    /// <param name="PrepmtSalesLine">Temp tables with prepayment sales lines.</param>    /// <param name="SalesHeader">The sales header of the document being posted.</param>    procedure DividePrepmtAmountLCY(var PrepmtSalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header")    var        ActualCurrencyFactor: Decimal;    begin        PrepmtSalesLine.Reset();        PrepmtSalesLine.SetFilter(Type, '<>%1', PrepmtSalesLine.Type::" ");        if PrepmtSalesLine.FindSet() then            repeat                if SalesHeader."Currency Code" <> '' then                    ActualCurrencyFactor :=                      Round(                        CurrExchRate.ExchangeAmtFCYToLCY(                          SalesHeader."Posting Date",                          SalesHeader."Currency Code",                          PrepmtSalesLine."Prepmt Amt to Deduct",                          SalesHeader."Currency Factor")) /                      PrepmtSalesLine."Prepmt Amt to Deduct"                else                    ActualCurrencyFactor := 1;                UpdatePrepmtAmountInvBuf(PrepmtSalesLine."Line No.", ActualCurrencyFactor);            until PrepmtSalesLine.Next() = 0;        PrepmtSalesLine.Reset();    end;    local procedure UpdatePrepmtAmountInvBuf(PrepmtSalesLineNo: Integer; CurrencyFactor: Decimal)    var        PrepmtAmtRemainder: Decimal;    begin        TempPrepmtDeductLCYSalesLine.Reset();        TempPrepmtDeductLCYSalesLine.SetRange("Attached to Line No.", PrepmtSalesLineNo);        if TempPrepmtDeductLCYSalesLine.FindSet(true) then            repeat                TempPrepmtDeductLCYSalesLine."Prepmt. Amount Inv. (LCY)" :=                  CalcRoundedAmount(CurrencyFactor * TempPrepmtDeductLCYSalesLine."VAT Base Amount", PrepmtAmtRemainder);                TempPrepmtDeductLCYSalesLine.Modify();            until TempPrepmtDeductLCYSalesLine.Next() = 0;    end;    local procedure AdjustPrepmtAmountLCY(SalesHeader: Record "Sales Header"; var PrepmtSalesLine: Record "Sales Line")    var        SalesLine: Record "Sales Line";        SalesInvoiceLine: Record "Sales Line";        TempSalesLineShipmentBuffer: Record "Sales Line" temporary;        DeductionFactor: Decimal;        PrepmtVATPart: Decimal;        PrepmtVATAmtRemainder: Decimal;        TotalRoundingAmount: array[2] of Decimal;        TotalPrepmtAmount: array[2] of Decimal;        FinalInvoice: Boolean;        PricesInclVATRoundingAmount: array[2] of Decimal;        CurrentLineFinalInvoice: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeAdjustPrepmtAmountLCY(SalesHeader, PrepmtSalesLine, IsHandled);        if IsHandled then            exit;        if PrepmtSalesLine."Prepayment Line" then begin            PrepmtVATPart :=              (PrepmtSalesLine."Amount Including VAT" - PrepmtSalesLine.Amount) / PrepmtSalesLine."Unit Price";            OnAdjustPrepmtAmountLCYOnAfterCalcPrepmtVATPart(PrepmtVATPart, SalesHeader, PrepmtSalesLine);            TempPrepmtDeductLCYSalesLine.Reset();            TempPrepmtDeductLCYSalesLine.SetRange("Attached to Line No.", PrepmtSalesLine."Line No.");            if TempPrepmtDeductLCYSalesLine.FindSet(true) then begin                FinalInvoice := true;                repeat                    SalesLine := TempPrepmtDeductLCYSalesLine;                    SalesLine.Find();                    if TempPrepmtDeductLCYSalesLine."Document Type" = TempPrepmtDeductLCYSalesLine."Document Type"::Invoice then begin                        SalesInvoiceLine := SalesLine;                        GetSalesOrderLine(SalesLine, SalesInvoiceLine);                        SalesLine."Qty. to Invoice" := SalesInvoiceLine."Qty. to Invoice";                        OnAdjustPrepmtAmountLCYOnAfterGetOrderLine(SalesLine, SalesInvoiceLine);                        TempSalesLineShipmentBuffer := SalesLine;                        if TempSalesLineShipmentBuffer.Find() then begin                            TempSalesLineShipmentBuffer."Qty. to Invoice" += TempPrepmtDeductLCYSalesLine."Qty. to Invoice";                            TempSalesLineShipmentBuffer.Modify();                        end else begin                            TempSalesLineShipmentBuffer.Quantity := TempPrepmtDeductLCYSalesLine.Quantity;                            TempSalesLineShipmentBuffer."Qty. to Invoice" := TempPrepmtDeductLCYSalesLine."Qty. to Invoice";                            TempSalesLineShipmentBuffer.Insert();                        end;                        CurrentLineFinalInvoice := TempSalesLineShipmentBuffer.IsFinalInvoice();                    end else begin                        CurrentLineFinalInvoice := TempPrepmtDeductLCYSalesLine.IsFinalInvoice();                        FinalInvoice := FinalInvoice and CurrentLineFinalInvoice;                    end;                    if SalesLine."Qty. to Invoice" <> TempPrepmtDeductLCYSalesLine."Qty. to Invoice" then                        SalesLine."Prepmt Amt to Deduct" := CalcPrepmtAmtToDeduct(SalesLine, SalesHeader.Ship);                    DeductionFactor :=                      SalesLine."Prepmt Amt to Deduct" /                      (SalesLine."Prepmt. Amt. Inv." - SalesLine."Prepmt Amt Deducted");                    TempPrepmtDeductLCYSalesLine."Prepmt. VAT Amount Inv. (LCY)" :=                      CalcRoundedAmount(SalesLine."Prepmt Amt to Deduct" * PrepmtVATPart, PrepmtVATAmtRemainder);                    if (TempPrepmtDeductLCYSalesLine."Prepayment %" <> 100) or CurrentLineFinalInvoice or (TempPrepmtDeductLCYSalesLine."Currency Code" <> '') then                        CalcPrepmtRoundingAmounts(TempPrepmtDeductLCYSalesLine, SalesLine, DeductionFactor, TotalRoundingAmount);                    TempPrepmtDeductLCYSalesLine.Modify();                    if SalesHeader."Prices Including VAT" then                        if ((TempPrepmtDeductLCYSalesLine."Prepayment %" <> 100) or CurrentLineFinalInvoice) and (DeductionFactor = 1) then begin                            PricesInclVATRoundingAmount[1] := TotalRoundingAmount[1];                            PricesInclVATRoundingAmount[2] := TotalRoundingAmount[2];                        end;                    if TempPrepmtDeductLCYSalesLine."VAT Calculation Type" <> TempPrepmtDeductLCYSalesLine."VAT Calculation Type"::"Full VAT" then                        TotalPrepmtAmount[1] += TempPrepmtDeductLCYSalesLine."Prepmt. Amount Inv. (LCY)";                    TotalPrepmtAmount[2] += TempPrepmtDeductLCYSalesLine."Prepmt. VAT Amount Inv. (LCY)";                until TempPrepmtDeductLCYSalesLine.Next() = 0;            end;            if FinalInvoice then                if TempSalesLineShipmentBuffer.FindSet() then                    repeat                        if not TempSalesLineShipmentBuffer.IsFinalInvoice() then                            FinalInvoice := false;                    until not FinalInvoice or (TempSalesLineShipmentBuffer.Next() = 0);            if SalesHeader."Document Type" <> SalesHeader."Document Type"::"Credit Memo" then                UpdatePrepmtSalesLineWithRounding(                  PrepmtSalesLine, TotalRoundingAmount, TotalPrepmtAmount,                  FinalInvoice, PricesInclVATRoundingAmount);        end;    end;    local procedure CalcPrepmtAmtToDeduct(SalesLine: Record "Sales Line"; Ship: Boolean): Decimal    var        IsHandled: Boolean;        PrepmtAmtToDeduct: Decimal;    begin        OnBeforeCalcPrepmtAmtToDeduct(SalesLine, Ship, IsHandled, PrepmtAmtToDeduct);        if IsHandled then            exit(PrepmtAmtToDeduct);        SalesLine."Qty. to Invoice" := GetQtyToInvoice(SalesLine, Ship);        SalesLine.CalcPrepaymentToDeduct();        exit(SalesLine."Prepmt Amt to Deduct");    end;    local procedure GetQtyToInvoice(SalesLine: Record "Sales Line"; Ship: Boolean): Decimal    var        AllowedQtyToInvoice: Decimal;        QtyToInvoice: Decimal;        IsHandled: Boolean;    begin        OnBeforeGetQtyToInvoice(SalesLine, Ship, IsHandled, QtyToInvoice);        if IsHandled then            exit(QtyToInvoice);        AllowedQtyToInvoice := SalesLine."Qty. Shipped Not Invoiced";        if Ship then            AllowedQtyToInvoice := AllowedQtyToInvoice + SalesLine."Qty. to Ship";        if SalesLine."Qty. to Invoice" > AllowedQtyToInvoice then            exit(AllowedQtyToInvoice);        exit(SalesLine."Qty. to Invoice");    end;    local procedure GetLineDataFromOrder(var SalesLine: Record "Sales Line")    var        SalesShptLine: Record "Sales Shipment Line";        SalesOrderLine: Record "Sales Line";    begin        SalesShptLine.Get(SalesLine."Shipment No.", SalesLine."Shipment Line No.");        SalesOrderLine.Get(SalesLine."Document Type"::Order, SalesShptLine."Order No.", SalesShptLine."Order Line No.");        SalesLine.Quantity := SalesOrderLine.Quantity;        SalesLine."Qty. Shipped Not Invoiced" := SalesOrderLine."Qty. Shipped Not Invoiced";        SalesLine."Quantity Invoiced" := SalesOrderLine."Quantity Invoiced";        SalesLine."Prepmt Amt Deducted" := SalesOrderLine."Prepmt Amt Deducted";        SalesLine."Prepmt. Amt. Inv." := SalesOrderLine."Prepmt. Amt. Inv.";        SalesLine."Line Discount Amount" := SalesOrderLine."Line Discount Amount";        OnAfterGetLineDataFromOrder(SalesLine, SalesOrderLine);    end;    local procedure CalcPrepmtRoundingAmounts(var PrepmtSalesLineBuf: Record "Sales Line"; SalesLine: Record "Sales Line"; DeductionFactor: Decimal; var TotalRoundingAmount: array[2] of Decimal)    var        RoundingAmount: array[2] of Decimal;    begin        if PrepmtSalesLineBuf."VAT Calculation Type" <> PrepmtSalesLineBuf."VAT Calculation Type"::"Full VAT" then begin            RoundingAmount[1] :=              PrepmtSalesLineBuf."Prepmt. Amount Inv. (LCY)" - Round(DeductionFactor * SalesLine."Prepmt. Amount Inv. (LCY)");            PrepmtSalesLineBuf."Prepmt. Amount Inv. (LCY)" := PrepmtSalesLineBuf."Prepmt. Amount Inv. (LCY)" - RoundingAmount[1];            TotalRoundingAmount[1] += RoundingAmount[1];        end;        RoundingAmount[2] :=          PrepmtSalesLineBuf."Prepmt. VAT Amount Inv. (LCY)" - Round(DeductionFactor * SalesLine."Prepmt. VAT Amount Inv. (LCY)");        PrepmtSalesLineBuf."Prepmt. VAT Amount Inv. (LCY)" := PrepmtSalesLineBuf."Prepmt. VAT Amount Inv. (LCY)" - RoundingAmount[2];        TotalRoundingAmount[2] += RoundingAmount[2];    end;    /// <summary>    /// Updates the prepayment sales line with rounding adjustments.    /// </summary>    /// <param name="PrepmtSalesLine">The prepayment sales line to update.</param>    /// <param name="TotalRoundingAmount">Array with the total rounding amount to add. First value is the amount excluding VAT, second value is the VAT amount.</param>    /// <param name="TotalPrepmtAmount">Array with the total prepayment amount to deduct. First value is the amount excluding VAT, second value is the VAT amount.</param>    /// <param name="FinalInvoice">Indicates if the current invoice is the final invoice.</param>    /// <param name="PricesInclVATRoundingAmount">Array with the rounding amount to add to the prices including VAT. First value is the amount excluding VAT, second value is the VAT amount.</param>    procedure UpdatePrepmtSalesLineWithRounding(var PrepmtSalesLine: Record "Sales Line"; TotalRoundingAmount: array[2] of Decimal; TotalPrepmtAmount: array[2] of Decimal; FinalInvoice: Boolean; PricesInclVATRoundingAmount: array[2] of Decimal)    var        NewAmountIncludingVAT: Decimal;        Prepmt100PctVATRoundingAmt: Decimal;        AmountRoundingPrecision: Decimal;    begin        OnBeforeUpdatePrepmtSalesLineWithRounding(          PrepmtSalesLine, TotalRoundingAmount, TotalPrepmtAmount, FinalInvoice, PricesInclVATRoundingAmount,          TotalSalesLine, TotalSalesLineLCY);        NewAmountIncludingVAT := TotalPrepmtAmount[1] + TotalPrepmtAmount[2] + TotalRoundingAmount[1] + TotalRoundingAmount[2];        if PrepmtSalesLine."Prepayment %" = 100 then            TotalRoundingAmount[1] += PrepmtSalesLine."Amount Including VAT" - NewAmountIncludingVAT;        AmountRoundingPrecision :=          GetAmountRoundingPrecisionInLCY(PrepmtSalesLine."Document Type", PrepmtSalesLine."Document No.", PrepmtSalesLine."Currency Code");        if (Abs(TotalRoundingAmount[1]) <= AmountRoundingPrecision) and           (Abs(TotalRoundingAmount[2]) <= AmountRoundingPrecision) and           (PrepmtSalesLine."Prepayment %" = 100)        then begin            Prepmt100PctVATRoundingAmt := TotalRoundingAmount[1];            TotalRoundingAmount[1] := 0;        end;        if (PricesInclVATRoundingAmount[1] <> 0) and (PricesInclVATRoundingAmount[1] = TotalRoundingAmount[1]) and           (PricesInclVATRoundingAmount[2] = 0) and (PricesInclVATRoundingAmount[2] = TotalRoundingAmount[2])           and FinalInvoice and (PrepmtSalesLine."Prepayment %" <> 100)        then begin            PricesInclVATRoundingAmount[1] := 0;            TotalRoundingAmount[1] := 0;        end;        PrepmtSalesLine."Prepmt. Amount Inv. (LCY)" := TotalRoundingAmount[1];        PrepmtSalesLine.Amount := TotalPrepmtAmount[1] + TotalRoundingAmount[1];        if (PricesInclVATRoundingAmount[1] <> 0) and (TotalRoundingAmount[1] = 0) then begin            if (PrepmtSalesLine."Prepayment %" = 100) and FinalInvoice and               (PrepmtSalesLine.Amount + TotalPrepmtAmount[2] = PrepmtSalesLine."Amount Including VAT")            then                Prepmt100PctVATRoundingAmt := 0;            PricesInclVATRoundingAmount[1] := 0;        end;        if ((TotalRoundingAmount[2] <> 0) or FinalInvoice) and (TotalRoundingAmount[1] = 0) then begin            if (PrepmtSalesLine."Prepayment %" = 100) and (PrepmtSalesLine."Prepmt. Amount Inv. (LCY)" = 0) then                Prepmt100PctVATRoundingAmt += TotalRoundingAmount[2];            if (PrepmtSalesLine."Prepayment %" = 100) or FinalInvoice then                TotalRoundingAmount[2] := 0;        end;        if (PricesInclVATRoundingAmount[2] <> 0) and (TotalRoundingAmount[2] = 0) then begin            if Abs(Prepmt100PctVATRoundingAmt) <= AmountRoundingPrecision then                Prepmt100PctVATRoundingAmt := 0;            PricesInclVATRoundingAmount[2] := 0;        end;        PrepmtSalesLine."Prepmt. VAT Amount Inv. (LCY)" := TotalRoundingAmount[2] + Prepmt100PctVATRoundingAmt;        NewAmountIncludingVAT := PrepmtSalesLine.Amount + TotalPrepmtAmount[2] + TotalRoundingAmount[2];        if (PricesInclVATRoundingAmount[1] = 0) and (PricesInclVATRoundingAmount[2] = 0) or           (PrepmtSalesLine."Currency Code" <> '') and FinalInvoice        then            TotalSalesLineLCY."Amount Including VAT" += PrepmtSalesLine."Amount Including VAT" - NewAmountIncludingVAT - Prepmt100PctVATRoundingAmt;        if PrepmtSalesLine."Currency Code" = '' then            TotalSalesLine."Amount Including VAT" := TotalSalesLineLCY."Amount Including VAT";        PrepmtSalesLine."Amount Including VAT" := NewAmountIncludingVAT;        if FinalInvoice and (TotalSalesLine.Amount = 0) and (TotalSalesLine."Amount Including VAT" <> 0) and           (Abs(TotalSalesLine."Amount Including VAT") <= Currency."Amount Rounding Precision")        then begin            PrepmtSalesLine."Amount Including VAT" += TotalSalesLineLCY."Amount Including VAT";            TotalSalesLine."Amount Including VAT" := 0;            TotalSalesLineLCY."Amount Including VAT" := 0;        end;        OnAfterUpdatePrepmtSalesLineWithRounding(          PrepmtSalesLine, TotalRoundingAmount, TotalPrepmtAmount, FinalInvoice, PricesInclVATRoundingAmount,          TotalSalesLine, TotalSalesLineLCY);    end;    local procedure CalcRoundedAmount(Amount: Decimal; var Remainder: Decimal): Decimal    var        AmountRnded: Decimal;    begin        Amount := Amount + Remainder;        AmountRnded := Round(Amount, GLSetup."Amount Rounding Precision");        Remainder := Amount - AmountRnded;        exit(AmountRnded);    end;    local procedure GetSalesOrderLine(var SalesOrderLine: Record "Sales Line"; SalesLine: Record "Sales Line")    var        SalesShptLine: Record "Sales Shipment Line";    begin        SalesShptLine.Get(SalesLine."Shipment No.", SalesLine."Shipment Line No.");        SalesOrderLine.Get(          SalesOrderLine."Document Type"::Order,          SalesShptLine."Order No.", SalesShptLine."Order Line No.");        SalesOrderLine."Prepmt Amt to Deduct" := SalesLine."Prepmt Amt to Deduct";    end;    /// <summary>    ///  Decrements the prepayment amount invoiced in LCY and the prepayment VAT amount invoiced in LCY for a given sales line.    /// </summary>    /// <param name="SalesHeader">The sales header of the document being posted.</param>    /// <param name="SalesLine">The sales line of the document for which the prepayment amount is being calculated.</param>    /// <param name="PrepmtAmountInvLCY">The invoiced prepayment amount of a sales line. The amount passed in gets reduced by the amount to be deducted.</param>    /// <param name="PrepmtVATAmountInvLCY">The invoiced prepayment VAT amount of a sales line. The amount passed in gets reduced by the amount to be deducted.</param>    procedure DecrementPrepmtAmtInvLCY(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var PrepmtAmountInvLCY: Decimal; var PrepmtVATAmountInvLCY: Decimal)    begin        TempPrepmtDeductLCYSalesLine.Reset();        if TempPrepmtDeductLCYSalesLine.Get(SalesLine."Document Type", SalesLine."Document No.", SalesLine."Line No.") then begin            PrepmtAmountInvLCY := PrepmtAmountInvLCY - TempPrepmtDeductLCYSalesLine."Prepmt. Amount Inv. (LCY)";            PrepmtVATAmountInvLCY := PrepmtVATAmountInvLCY - TempPrepmtDeductLCYSalesLine."Prepmt. VAT Amount Inv. (LCY)";        end;        OnAfterDecrementPrepmtAmtInvLCY(SalesHeader, SalesLine, PrepmtAmountInvLCY, PrepmtVATAmountInvLCY);    end;    local procedure AdjustFinalInvWith100PctPrepmt(var CombinedSalesLine: Record "Sales Line")    var        DiffToLineDiscAmt: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeAdjustFinalInvWith100PctPrepmt(TempPrepmtDeductLCYSalesLine, CombinedSalesLine, IsHandled);        if IsHandled then            exit;        TempPrepmtDeductLCYSalesLine.Reset();        TempPrepmtDeductLCYSalesLine.SetRange(TempPrepmtDeductLCYSalesLine."Prepayment %", 100);        if TempPrepmtDeductLCYSalesLine.FindSet(true) then            repeat                if TempPrepmtDeductLCYSalesLine.IsFinalInvoice() then begin                    DiffToLineDiscAmt := TempPrepmtDeductLCYSalesLine."Prepmt Amt to Deduct" - TempPrepmtDeductLCYSalesLine."Line Amount";                    if TempPrepmtDeductLCYSalesLine."Document Type" = TempPrepmtDeductLCYSalesLine."Document Type"::Order then                        DiffToLineDiscAmt := DiffToLineDiscAmt * TempPrepmtDeductLCYSalesLine.Quantity / TempPrepmtDeductLCYSalesLine."Qty. to Invoice";                    if DiffToLineDiscAmt <> 0 then begin                        CombinedSalesLine.Get(TempPrepmtDeductLCYSalesLine."Document Type", TempPrepmtDeductLCYSalesLine."Document No.", TempPrepmtDeductLCYSalesLine."Line No.");                        TempPrepmtDeductLCYSalesLine."Line Discount Amount" := CombinedSalesLine."Line Discount Amount" - DiffToLineDiscAmt;                        TempPrepmtDeductLCYSalesLine.Modify();                    end;                end;            until TempPrepmtDeductLCYSalesLine.Next() = 0;        TempPrepmtDeductLCYSalesLine.Reset();    end;    local procedure GetPrepmtDiffToLineAmount(SalesLine: Record "Sales Line"): Decimal    begin        if SalesLine."Prepayment %" = 100 then            if TempPrepmtDeductLCYSalesLine.Get(SalesLine."Document Type", SalesLine."Document No.", SalesLine."Line No.") then                exit(TempPrepmtDeductLCYSalesLine."Prepmt Amt to Deduct" + TempPrepmtDeductLCYSalesLine."Inv. Disc. Amount to Invoice" - TempPrepmtDeductLCYSalesLine."Line Amount");        exit(0);    end;    local procedure PostJobContractLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostJobContractLine(            SalesHeader, SalesLine, IsHandled, JobContractLine, InvoicePostingInterface, SalesLineACY, SalesInvHeader, SalesCrMemoHeader);        if not IsHandled then begin            if SalesLine."Job Contract Entry No." = 0 then                exit;            IsHandled := false;            OnPostJobContractLineBeforeTestFields(SalesHeader, SalesLine, IsHandled);            if not IsHandled then begin                if (SalesHeader."Document Type" <> SalesHeader."Document Type"::Invoice) and                   (SalesHeader."Document Type" <> SalesHeader."Document Type"::"Credit Memo")                then                    SalesLine.TestField("Job Contract Entry No.", 0);                SalesLine.TestField("Job No.");                SalesLine.TestField("Job Task No.");            end;            if SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice then                SalesLine."Document No." := SalesInvHeader."No.";            if SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo" then                SalesLine."Document No." := SalesCrMemoHeader."No.";            JobContractLine := true;            InvoicePostingInterface.PrepareJobLine(SalesHeader, SalesLine, SalesLineACY);        end;        OnAfterPostJobContractLine(SalesHeader, SalesLine, GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode);    end;    local procedure InsertICGenJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var ICGenJnlLineNo: Integer)    var        ICGLAccount: Record "IC G/L Account";        ICPartner: Record "IC Partner";        GenJnlLine: Record "Gen. Journal Line";    begin        SalesHeader.TestField("Sell-to IC Partner Code", '');        SalesHeader.TestField("Bill-to IC Partner Code", '');        SalesLine.TestField("IC Partner Ref. Type", SalesLine."IC Partner Ref. Type"::"G/L Account");        ICGLAccount.Get(SalesLine."IC Partner Reference");        ICGenJnlLineNo := ICGenJnlLineNo + 1;        TempICGenJnlLine.InitNewLine(            SalesHeader."Posting Date", SalesHeader."Document Date", SalesHeader."VAT Reporting Date", SalesHeader."Posting Description",            SalesLine."Shortcut Dimension 1 Code", SalesLine."Shortcut Dimension 2 Code", SalesLine."Dimension Set ID",            SalesHeader."Reason Code");        TempICGenJnlLine."Line No." := ICGenJnlLineNo;        TempICGenJnlLine.CopyDocumentFields(GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series");        TempICGenJnlLine."Account Type" := TempICGenJnlLine."Account Type"::"IC Partner";        TempICGenJnlLine.Validate(TempICGenJnlLine."Account No.", SalesLine."IC Partner Code");        TempICGenJnlLine."Source Currency Code" := SalesHeader."Currency Code";        TempICGenJnlLine."Source Currency Amount" := TempICGenJnlLine.Amount;        TempICGenJnlLine.Correction := SalesHeader.Correction;        TempICGenJnlLine."Country/Region Code" := SalesHeader."VAT Country/Region Code";        TempICGenJnlLine."Source Type" := GenJnlLine."Source Type"::Customer;        TempICGenJnlLine."Source No." := SalesHeader."Bill-to Customer No.";        TempICGenJnlLine."Source Line No." := SalesLine."Line No.";        TempICGenJnlLine.Validate("Bal. Account Type", TempICGenJnlLine."Bal. Account Type"::"G/L Account");        TempICGenJnlLine.Validate("Bal. Account No.", SalesLine."No.");        TempICGenJnlLine."Shortcut Dimension 1 Code" := SalesLine."Shortcut Dimension 1 Code";        TempICGenJnlLine."Shortcut Dimension 2 Code" := SalesLine."Shortcut Dimension 2 Code";        TempICGenJnlLine."Dimension Set ID" := SalesLine."Dimension Set ID";        ValidateICPartnerBusPostingGroups(SalesLine);        TempICGenJnlLine.Validate("Bal. VAT Prod. Posting Group", SalesLine."VAT Prod. Posting Group");        TempICGenJnlLine."IC Partner Code" := SalesLine."IC Partner Code";        TempICGenJnlLine."IC Account Type" := TempICGenJnlLine."IC Account Type"::"G/L Account";        TempICGenJnlLine."IC Account No." := SalesLine."IC Partner Reference";        TempICGenJnlLine."IC Direction" := TempICGenJnlLine."IC Direction"::Outgoing;        ICPartner.Get(SalesLine."IC Partner Code");        if ICPartner."Cost Distribution in LCY" and (SalesLine."Currency Code" <> '') then begin            TempICGenJnlLine."Currency Code" := '';            TempICGenJnlLine."Currency Factor" := 0;            Currency.Get(SalesLine."Currency Code");            if SalesHeader.IsCreditDocType() then                TempICGenJnlLine.Amount :=                  Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      SalesHeader."Posting Date", SalesLine."Currency Code",                      SalesLine.Amount, SalesHeader."Currency Factor"))            else                TempICGenJnlLine.Amount :=                  -Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      SalesHeader."Posting Date", SalesLine."Currency Code",                      SalesLine.Amount, SalesHeader."Currency Factor"));        end else begin            Currency.InitRoundingPrecision();            TempICGenJnlLine."Currency Code" := SalesHeader."Currency Code";            TempICGenJnlLine."Currency Factor" := SalesHeader."Currency Factor";            if SalesHeader.IsCreditDocType() then                TempICGenJnlLine.Amount := SalesLine.Amount            else                TempICGenJnlLine.Amount := -SalesLine.Amount;        end;        if TempICGenJnlLine."Bal. VAT %" <> 0 then            TempICGenJnlLine.Amount := Round(TempICGenJnlLine.Amount * (1 + TempICGenJnlLine."Bal. VAT %" / 100), Currency."Amount Rounding Precision");        TempICGenJnlLine.Validate(Amount);        TempICGenJnlLine."Journal Template Name" := SalesLine.GetJnlTemplateName();        OnBeforeInsertICGenJnlLine(TempICGenJnlLine, SalesHeader, SalesLine, SuppressCommit);        TempICGenJnlLine.Insert();    end;    local procedure ValidateICPartnerBusPostingGroups(SalesLine: Record "Sales Line")    var        Vendor: Record Vendor;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeValidateICPartnerBusPostingGroups(TempICGenJnlLine, SalesLine, IsHandled);        if IsHandled then            exit;        Vendor.SetCurrentKey("IC Partner Code");        Vendor.SetRange("IC Partner Code", SalesLine."IC Partner Code");        if Vendor.FindFirst() then begin            TempICGenJnlLine.Validate("Bal. Gen. Bus. Posting Group", Vendor."Gen. Bus. Posting Group");            TempICGenJnlLine.Validate("Bal. VAT Bus. Posting Group", Vendor."VAT Bus. Posting Group");        end;    end;    local procedure PostICGenJnl()    var        ICInOutBoxMgt: Codeunit ICInboxOutboxMgt;        ICOutboxExport: Codeunit "IC Outbox Export";        ICTransactionNo: Integer;    begin        TempICGenJnlLine.Reset();        TempICGenJnlLine.SetFilter(Amount, '<>%1', 0);        if TempICGenJnlLine.Find('-') then            repeat                ICTransactionNo := ICInOutBoxMgt.CreateOutboxJnlTransaction(TempICGenJnlLine, false);                ICInOutBoxMgt.CreateOutboxJnlLine(ICTransactionNo, 1, TempICGenJnlLine);                ICOutboxExport.ProcessAutoSendOutboxTransactionNo(ICTransactionNo);                if TempICGenJnlLine.Amount <> 0 then                    GenJnlPostLine.RunWithCheck(TempICGenJnlLine);            until TempICGenJnlLine.Next() = 0;    end;    /// <summary>    /// Checks if the prepayment amount for the sales lines is too big or too small using information from the related sales order lines.    /// It throws an error if it is.    /// </summary>    /// <remarks>    /// It is too big if the prepayment amount is bigger than the remaining prepayment amount on the sales order line.    /// It is too small if the prepayment amount is smaller than the remaining prepayment amount on the sales order line and the sales order line is fully invoiced.    /// If this is the last invoice and the sales line has 100% prepayment, then the actual (non-temp) invoice line is adjusted so that prepayment amount to deduct equals the line amount.    /// </remarks>    procedure TestGetShipmentPPmtAmtToDeduct()    var        TempSalesLine: Record "Sales Line" temporary;        TempShippedSalesLine: Record "Sales Line" temporary;        TempTotalSalesLine: Record "Sales Line" temporary;        TempSalesShptLine: Record "Sales Shipment Line" temporary;        SalesShptLine: Record "Sales Shipment Line";        SalesOrderLine: Record "Sales Line";        MaxAmtToDeduct: Decimal;    begin        ResetTempLines(TempSalesLine);        TempSalesLine.SetFilter(Quantity, '>0');        TempSalesLine.SetFilter("Qty. to Invoice", '>0');        TempSalesLine.SetFilter("Shipment No.", '<>%1', '');        TempSalesLine.SetFilter("Prepmt Amt to Deduct", '<>0');        if TempSalesLine.IsEmpty() then            exit;        TempSalesLine.SetRange("Prepmt Amt to Deduct");        if TempSalesLine.FindSet() then            repeat                if SalesShptLine.Get(TempSalesLine."Shipment No.", TempSalesLine."Shipment Line No.") then begin                    TempShippedSalesLine := TempSalesLine;                    TempShippedSalesLine.Insert();                    TempSalesShptLine := SalesShptLine;                    if TempSalesShptLine.Insert() then;                    if not TempTotalSalesLine.Get(TempSalesLine."Document Type"::Order, SalesShptLine."Order No.", SalesShptLine."Order Line No.") then begin                        TempTotalSalesLine.Init();                        TempTotalSalesLine."Document Type" := TempSalesLine."Document Type"::Order;                        TempTotalSalesLine."Document No." := SalesShptLine."Order No.";                        TempTotalSalesLine."Line No." := SalesShptLine."Order Line No.";                        TempTotalSalesLine.Insert();                    end;                    TempTotalSalesLine."Qty. to Invoice" := TempTotalSalesLine."Qty. to Invoice" + TempSalesLine."Qty. to Invoice";                    TempTotalSalesLine."Prepmt Amt to Deduct" := TempTotalSalesLine."Prepmt Amt to Deduct" + TempSalesLine."Prepmt Amt to Deduct";                    AdjustInvLineWith100PctPrepmt(TempSalesLine, TempTotalSalesLine);                    TempTotalSalesLine.Modify();                end;            until TempSalesLine.Next() = 0;        if TempShippedSalesLine.FindSet() then            repeat                if TempSalesShptLine.Get(TempShippedSalesLine."Shipment No.", TempShippedSalesLine."Shipment Line No.") then                    if SalesOrderLine.Get(                         TempShippedSalesLine."Document Type"::Order, TempSalesShptLine."Order No.", TempSalesShptLine."Order Line No.")                    then                        if TempTotalSalesLine.Get(                             TempShippedSalesLine."Document Type"::Order, TempSalesShptLine."Order No.", TempSalesShptLine."Order Line No.")                        then begin                            MaxAmtToDeduct := SalesOrderLine."Prepmt. Amt. Inv." - SalesOrderLine."Prepmt Amt Deducted";                            CheckTotalPrepmtAmtToDeduct(TempSalesLine, TempTotalSalesLine, MaxAmtToDeduct);                            if (TempTotalSalesLine."Qty. to Invoice" = SalesOrderLine.Quantity - SalesOrderLine."Quantity Invoiced") and                               (SalesOrderLine."Prepmt Amt to Deduct" <> MaxAmtToDeduct)                            then                                Error(PrepAmountToDeductToSmallErr, TempSalesLine.FieldCaption(TempSalesLine."Prepmt Amt to Deduct"), MaxAmtToDeduct);                        end;            until TempShippedSalesLine.Next() = 0;    end;    local procedure CheckTotalPrepmtAmtToDeduct(var TempSalesLine: Record "Sales Line" temporary; var TempTotalSalesLine: Record "Sales Line" temporary; MaxAmtToDeduct: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckTotalPrepmtAmtToDeduct(TempSalesLine, TempTotalSalesLine, MaxAmtToDeduct, IsHandled);        if IsHandled then            exit;        if TempTotalSalesLine."Prepmt Amt to Deduct" > MaxAmtToDeduct then            Error(PrepAmountToDeductToBigErr, TempSalesLine.FieldCaption("Prepmt Amt to Deduct"), MaxAmtToDeduct);    end;    local procedure AdjustInvLineWith100PctPrepmt(var SalesInvoiceLine: Record "Sales Line"; var TempTotalSalesLine: Record "Sales Line" temporary)    var        SalesOrderLine: Record "Sales Line";        DiffAmtToDeduct: Decimal;    begin        if SalesInvoiceLine."Prepayment %" = 100 then begin            SalesOrderLine.Get(TempTotalSalesLine."Document Type", TempTotalSalesLine."Document No.", TempTotalSalesLine."Line No.");            if TempTotalSalesLine."Qty. to Invoice" = SalesOrderLine.Quantity - SalesOrderLine."Quantity Invoiced" then begin                DiffAmtToDeduct :=                  SalesOrderLine."Prepmt. Amt. Inv." - SalesOrderLine."Prepmt Amt Deducted" - TempTotalSalesLine."Prepmt Amt to Deduct";                if DiffAmtToDeduct <> 0 then begin                    SalesInvoiceLine."Prepmt Amt to Deduct" := SalesInvoiceLine."Prepmt Amt to Deduct" + DiffAmtToDeduct;                    SalesInvoiceLine."Line Amount" := SalesInvoiceLine."Prepmt Amt to Deduct";                    SalesInvoiceLine."Line Discount Amount" := SalesInvoiceLine."Line Discount Amount" - DiffAmtToDeduct;                    ModifyTempLine(SalesInvoiceLine);                    TempTotalSalesLine."Prepmt Amt to Deduct" := TempTotalSalesLine."Prepmt Amt to Deduct" + DiffAmtToDeduct;                end;            end;        end;    end;    /// <summary>    /// Archives unposted orders and return orders if archiving is enabled in the Sales Setup.    /// </summary>    /// <remarks>    /// Order isn't archived if there are no lines to archive or PreviewMode is true.    /// </remarks>    /// <param name="SalesHeader"></param>    procedure ArchiveUnpostedOrder(var SalesHeader: Record "Sales Header")    var        SalesLine: Record "Sales Line";        ArchiveManagement: Codeunit ArchiveManagement;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeArchiveUnpostedOrder(SalesHeader, IsHandled, PreviewMode, OrderArchived);        if IsHandled then            exit;        GetSalesSetup();        if not (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"]) then            exit;        if (SalesHeader."Document Type" = SalesHeader."Document Type"::Order) and not SalesSetup."Archive Orders" then            exit;        if (SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order") and not SalesSetup."Archive Return Orders" then            exit;        SalesLine.Reset();        SalesLine.SetRange("Document Type", SalesHeader."Document Type");        SalesLine.SetRange("Document No.", SalesHeader."No.");        SalesLine.SetFilter(Quantity, '<>0');        if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then            SalesLine.SetFilter("Qty. to Ship", '<>0')        else            SalesLine.SetFilter("Return Qty. to Receive", '<>0');        if not SalesLine.IsEmpty() and not PreviewMode then begin            ArchiveManagement.RoundSalesDeferralsForArchive(SalesHeader, SalesLine);            ArchiveManagement.ArchSalesDocumentNoConfirm(SalesHeader);            OrderArchived := true;        end;        OnAfterArchiveUnpostedOrder(SalesHeader, SalesLine, OrderArchived);    end;    /// <summary>    /// Retrieves the G/L Setup record if it hasn't been read before.    /// </summary>    procedure GetGLSetup()    begin        if not GLSetupRead then            GLSetup.Get();        GLSetupRead := true;        OnAfterGetGLSetup(GLSetup);    end;    local procedure GetSalesSetup()    begin        if not SalesSetupRead then            SalesSetup.Get();        SalesSetupRead := true;        OnAfterGetSalesSetup(SalesSetup);    end;    local procedure GetInvoicePostingSetup()    var        IsHandled: Boolean;    begin        if IsInterfaceInitalized then            exit;        IsHandled := false;        OnBeforeGetInvoicePostingSetup(InvoicePostingInterface, IsHandled);        if not IsHandled then            InvoicePostingInterface := Enum::"Sales Invoice Posting"::"Invoice Posting (v.19)";        InvoicePostingInterface.Check(Database::"Sales Header");        IsInterfaceInitalized := true;        InvoicePostingInterface.SetHideProgressWindow(HideProgressWindow);        InvoicePostingInterface.SetPreviewMode(PreviewMode);        InvoicePostingInterface.SetSuppressCommit(SuppressCommit);    end;    local procedure GetInvoicePostingParameters()    begin        InvoicePostingParameters."Document Type" := GenJnlLineDocType;        InvoicePostingParameters."Document No." := GenJnlLineDocNo;        InvoicePostingParameters."External Document No." := GenJnlLineExtDocNo;        InvoicePostingParameters."Source Code" := SrcCode;        InvoicePostingParameters."Auto Document No." := '';    end;    local procedure LockTables(var SalesHeader: Record "Sales Header")    var        SalesLine: Record "Sales Line";        PurchOrderHeader: Record "Purchase Header";        PurchOrderLine: Record "Purchase Line";        InventorySetup: Record "Inventory Setup";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeLockTables(SalesHeader, PreviewMode, SuppressCommit, IsHandled);        if IsHandled then            exit;        SalesLine.LockTable();        ItemChargeAssgntSales.LockTable();        PurchOrderLine.LockTable();        PurchOrderHeader.LockTable();        GetGLSetup();        if InventorySetup.UseLegacyPosting() and not InventorySetup.OptimGLEntLockForMultiuserEnv() then begin            GLEntry.LockTable();            GLEntry.GetLastEntryNo();        end;    end;    local procedure UpdateSalesHeader(var CustLedgerEntry: Record "Cust. Ledger Entry"; var SalesHeader: Record "Sales Header")    var        GenJnlLine: Record "Gen. Journal Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateSalesHeader(CustLedgerEntry, SalesInvHeader, SalesCrMemoHeader, GenJnlLineDocType.AsInteger(), IsHandled, GenJnlLineDocNo, PreviewMode, SalesHeader);        if IsHandled then            exit;        case GenJnlLineDocType of            GenJnlLine."Document Type"::Invoice:                begin                    FindCustLedgEntry(GenJnlLineDocType, GenJnlLineDocNo, CustLedgerEntry);                    SalesInvHeader."Cust. Ledger Entry No." := CustLedgerEntry."Entry No.";                    SalesInvHeader.Modify();                end;            GenJnlLine."Document Type"::"Credit Memo":                begin                    FindCustLedgEntry(GenJnlLineDocType, GenJnlLineDocNo, CustLedgerEntry);                    SalesCrMemoHeader."Cust. Ledger Entry No." := CustLedgerEntry."Entry No.";                    SalesCrMemoHeader.Modify();                end;        end;        OnAfterUpdateSalesHeader(CustLedgerEntry, SalesInvHeader, SalesCrMemoHeader, GenJnlLineDocType.AsInteger(), GenJnlLineDocNo, PreviewMode, SalesHeader);    end;    local procedure MakeSalesLineToShip(var SalesLineToShip: Record "Sales Line"; SalesLineInvoiced: Record "Sales Line")    var        TempSalesLine: Record "Sales Line" temporary;    begin        ResetTempLines(TempSalesLine);        TempSalesLine := SalesLineInvoiced;        TempSalesLine.Find();        SalesLineToShip := SalesLineInvoiced;        SalesLineToShip."Inv. Discount Amount" := TempSalesLine."Inv. Discount Amount";    end;    local procedure "MAX"(number1: Integer; number2: Integer): Integer    begin        if number1 > number2 then            exit(number1);        exit(number2);    end;    local procedure FindCustLedgEntry(DocType: Enum "Gen. Journal Document Type"; DocNo: Code[20]; var CustLedgEntry: Record "Cust. Ledger Entry")    begin        OnBeforeFindCustLedgEntry(CustLedgEntry);        CustLedgEntry.SetRange("Document Type", DocType);        CustLedgEntry.SetRange("Document No.", DocNo);        CustLedgEntry.FindLast();    end;    local procedure ItemLedgerEntryExist(SalesLine2: Record "Sales Line"; ShipOrReceive: Boolean): Boolean    var        HasItemLedgerEntry: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeItemLedgerEntryExist(SalesLine2, ShipOrReceive, HasItemLedgerEntry, IsHandled);        if IsHandled then            exit(HasItemLedgerEntry);        if ShipOrReceive then            // item ledger entry will be created during posting in this transaction            HasItemLedgerEntry :=            ((SalesLine2."Qty. to Ship" + SalesLine2."Quantity Shipped") <> 0) or            ((SalesLine2."Qty. to Invoice" + SalesLine2."Quantity Invoiced") <> 0) or            ((SalesLine2."Return Qty. to Receive" + SalesLine2."Return Qty. Received") <> 0)        else            // item ledger entry must already exist            HasItemLedgerEntry :=            (SalesLine2."Quantity Shipped" <> 0) or            (SalesLine2."Return Qty. Received" <> 0);        exit(HasItemLedgerEntry);    end;    local procedure CheckPostRestrictions(SalesHeader: Record "Sales Header")    var        Contact: Record Contact;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckPostRestrictions(SalesHeader, IsHandled);        if IsHandled then            exit;        if not PreviewMode then            SalesHeader.CheckSalesPostRestrictions();        CheckCustBlockage(SalesHeader, SalesHeader."Sell-to Customer No.", true);        SalesHeader.ValidateSalesPersonOnSalesHeader(SalesHeader, true, true);        if SalesHeader."Bill-to Customer No." <> SalesHeader."Sell-to Customer No." then            CheckCustBlockage(SalesHeader, SalesHeader."Bill-to Customer No.", false);        if SalesHeader."Sell-to Contact No." <> '' then            if Contact.Get(SalesHeader."Sell-to Contact No.") then                Contact.CheckIfPrivacyBlocked(true);        if SalesHeader."Bill-to Contact No." <> '' then            if Contact.Get(SalesHeader."Bill-to Contact No.") then                Contact.CheckIfPrivacyBlocked(true);    end;    local procedure CheckCustBlockage(SalesHeader: Record "Sales Header"; CustCode: Code[20]; ExecuteDocCheck: Boolean)    var        Cust: Record Customer;        TempSalesLine: Record "Sales Line" temporary;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckCustBlockage(SalesHeader, CustCode, ExecuteDocCheck, IsHandled, TempSalesLineGlobal);        if IsHandled then            exit;        Cust.Get(CustCode);        if SalesHeader.Receive then            Cust.CheckBlockedCustOnDocs(Cust, SalesHeader."Document Type", false, true)        else            if SalesHeader.Ship and CheckDocumentType(SalesHeader, ExecuteDocCheck) then begin                ResetTempLines(TempSalesLine);                TempSalesLine.SetFilter("Qty. to Ship", '<>0');                TempSalesLine.SetRange("Shipment No.", '');                OnCheckCustBlockageOnAfterTempLinesSetFilters(SalesHeader, TempSalesLine);                if not TempSalesLine.IsEmpty() then                    Cust.CheckBlockedCustOnDocs(Cust, SalesHeader."Document Type", true, true);            end else                Cust.CheckBlockedCustOnDocs(Cust, SalesHeader."Document Type", false, true);    end;    /// <summary>    /// Retrieves the General Posting Setup record for the specified sales line.    /// </summary>    /// <param name="GenPostingSetup">Return Variable: General Posting Setup record</param>    /// <param name="SalesLine">sales line for which to retrieve the Gen. Posting Setup</param>    procedure GetGeneralPostingSetup(var GenPostingSetup: Record "General Posting Setup"; SalesLine: Record "Sales Line")    begin        GenPostingSetup.Get(SalesLine."Gen. Bus. Posting Group", SalesLine."Gen. Prod. Posting Group");        OnAfterGetGeneralPostingSetup(GenPostingSetup, SalesLine);    end;    local procedure CheckDocumentType(SalesHeader: Record "Sales Header"; ExecuteDocCheck: Boolean): Boolean    begin        if ExecuteDocCheck then            exit(              (SalesHeader."Document Type" = SalesHeader."Document Type"::Order) or              ((SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice) and SalesSetup."Shipment on Invoice"));        exit(true);    end;    local procedure UpdateWonOpportunities(var SalesHeader: Record "Sales Header")    var        Opp: Record Opportunity;        OpportunityEntry: Record "Opportunity Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateWonOpportunities(SalesHeader, SalesInvHeader, IsHandled);        if not IsHandled then            if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then begin                Opp.Reset();                Opp.SetCurrentKey("Sales Document Type", "Sales Document No.");                Opp.SetRange("Sales Document Type", Opp."Sales Document Type"::Order);                Opp.SetRange("Sales Document No.", SalesHeader."No.");                Opp.SetRange(Status, Opp.Status::Won);                if Opp.FindFirst() then begin                    Opp."Sales Document Type" := Opp."Sales Document Type"::"Posted Invoice";                    Opp."Sales Document No." := SalesInvHeader."No.";                    OnUpdateWonOpportunitiesOnBeforeOpportunityModify(SalesHeader, SalesInvHeader, Opp);                    Opp.Modify();                    OpportunityEntry.Reset();                    OpportunityEntry.SetCurrentKey(Active, "Opportunity No.");                    OpportunityEntry.SetRange(Active, true);                    OpportunityEntry.SetRange("Opportunity No.", Opp."No.");                    if OpportunityEntry.FindFirst() then begin                        OpportunityEntry."Calcd. Current Value (LCY)" := OpportunityEntry.GetSalesDocValue(SalesHeader);                        OpportunityEntry.Modify();                    end;                end;            end;        OnAfterUpdateWonOpportunities(SalesHeader, SalesInvHeader);    end;    local procedure UpdateQtyToBeInvoicedForShipment(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; HasATOShippedNotInvoiced: Boolean; SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; InvoicingTrackingSpecification: Record "Tracking Specification"; ItemLedgEntryNotInvoiced: Record "Item Ledger Entry")    begin        OnBeforeUpdateQtyToBeInvoicedForShipment(            QtyToBeInvoiced, QtyToBeInvoicedBase, TrackingSpecificationExists, HasATOShippedNotInvoiced,            SalesLine, SalesShptLine, InvoicingTrackingSpecification);        if TrackingSpecificationExists then begin            QtyToBeInvoiced := InvoicingTrackingSpecification."Qty. to Invoice";            QtyToBeInvoicedBase := InvoicingTrackingSpecification."Qty. to Invoice (Base)";        end else            if HasATOShippedNotInvoiced then begin                QtyToBeInvoicedBase := ItemLedgEntryNotInvoiced.Quantity - ItemLedgEntryNotInvoiced."Invoiced Quantity";                if Abs(QtyToBeInvoicedBase) > Abs(RemQtyToBeInvoicedBase) then                    QtyToBeInvoicedBase := RemQtyToBeInvoicedBase - SalesLine."Qty. to Ship (Base)";                QtyToBeInvoiced := Round(QtyToBeInvoicedBase / SalesShptLine."Qty. per Unit of Measure", UOMMgt.QtyRndPrecision());            end else begin                QtyToBeInvoiced := RemQtyToBeInvoiced - SalesLine."Qty. to Ship";                QtyToBeInvoicedBase := RemQtyToBeInvoicedBase - SalesLine."Qty. to Ship (Base)";            end;        OnUpdateQtyToBeInvoicedForShipmentOnAfterSetQtyToBeInvoiced(            TrackingSpecificationExists, HasATOShippedNotInvoiced, QtyToBeInvoiced, QtyToBeInvoicedBase, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, SalesLine);        if Abs(QtyToBeInvoiced) > Abs(SalesShptLine.Quantity - SalesShptLine."Quantity Invoiced") then begin            QtyToBeInvoiced := -(SalesShptLine.Quantity - SalesShptLine."Quantity Invoiced");            QtyToBeInvoicedBase := -(SalesShptLine."Quantity (Base)" - SalesShptLine."Qty. Invoiced (Base)");        end;    end;    local procedure UpdateQtyToBeInvoicedForReturnReceipt(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; SalesLine: Record "Sales Line"; ReturnReceiptLine: Record "Return Receipt Line"; InvoicingTrackingSpecification: Record "Tracking Specification")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateQtyToBeInvoicedForReturnReceipt(            QtyToBeInvoiced, QtyToBeInvoicedBase, TrackingSpecificationExists, SalesLine, ReturnReceiptLine,            InvoicingTrackingSpecification, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, IsHandled);        if IsHandled then            exit;        if TrackingSpecificationExists then begin            QtyToBeInvoiced := InvoicingTrackingSpecification."Qty. to Invoice";            QtyToBeInvoicedBase := InvoicingTrackingSpecification."Qty. to Invoice (Base)";        end else begin            QtyToBeInvoiced := RemQtyToBeInvoiced - SalesLine."Return Qty. to Receive";            QtyToBeInvoicedBase := RemQtyToBeInvoicedBase - SalesLine."Return Qty. to Receive (Base)";        end;        OnUpdateQtyToBeInvoicedForReturnReceiptOnAfterSetQtyToBeInvoiced(TrackingSpecificationExists, QtyToBeInvoiced, QtyToBeInvoicedBase, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, SalesLine);        if Abs(QtyToBeInvoiced) >           Abs(ReturnReceiptLine.Quantity - ReturnReceiptLine."Quantity Invoiced")        then begin            QtyToBeInvoiced := ReturnReceiptLine.Quantity - ReturnReceiptLine."Quantity Invoiced";            QtyToBeInvoicedBase := ReturnReceiptLine."Quantity (Base)" - ReturnReceiptLine."Qty. Invoiced (Base)";        end;    end;    local procedure UpdateRemainingQtyToBeInvoiced(SalesShptLine: Record "Sales Shipment Line"; var RemQtyToInvoiceCurrLine: Decimal; var RemQtyToInvoiceCurrLineBase: Decimal)    var        IsHandled: Boolean;    begin        OnBeforeUpdateRemainingQtyToBeInvoiced(SalesShptLine, RemQtyToInvoiceCurrLine, RemQtyToInvoiceCurrLineBase, IsHandled);        if IsHandled then            exit;        RemQtyToInvoiceCurrLine := -SalesShptLine.Quantity + SalesShptLine."Quantity Invoiced";        RemQtyToInvoiceCurrLineBase := -SalesShptLine."Quantity (Base)" + SalesShptLine."Qty. Invoiced (Base)";        if RemQtyToInvoiceCurrLine < RemQtyToBeInvoiced then begin            RemQtyToInvoiceCurrLine := RemQtyToBeInvoiced;            RemQtyToInvoiceCurrLineBase := RemQtyToBeInvoicedBase;        end;    end;    local procedure IsEndLoopForShippedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var HasATOShippedNotInvoiced: Boolean; var SalesShptLine: Record "Sales Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; var ItemLedgEntryNotInvoiced: Record "Item Ledger Entry"; SalesLine: Record "Sales Line") Result: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeIsEndLoopForShippedNotInvoiced(            RemQtyToBeInvoiced, TrackingSpecificationExists, HasATOShippedNotInvoiced, SalesShptLine,            InvoicingTrackingSpecification, ItemLedgEntryNotInvoiced, SalesLine, Result, IsHandled);        if IsHandled then            exit(Result);        if TrackingSpecificationExists then            exit((InvoicingTrackingSpecification.Next() = 0) or (RemQtyToBeInvoiced = 0));        if HasATOShippedNotInvoiced then begin            HasATOShippedNotInvoiced := ItemLedgEntryNotInvoiced.Next() <> 0;            if not HasATOShippedNotInvoiced then                exit(not SalesShptLine.FindSet() or (Abs(RemQtyToBeInvoiced) <= Abs(SalesLine."Qty. to Ship")));            exit(Abs(RemQtyToBeInvoiced) <= Abs(SalesLine."Qty. to Ship"));        end;        IsHandled := false;        OnIsEndLoopForShippedNotInvoicedOnBeforeExit(SalesLine, SalesShptLine, RemQtyToBeInvoiced, Result, IsHandled);        if IsHandled then            exit(Result);        exit((SalesShptLine.Next() = 0) or (Abs(RemQtyToBeInvoiced) <= Abs(SalesLine."Qty. to Ship")));    end;    /// <summary>    /// Retrieves the Item Entry Relation and Sales Shipment Line that are related to the item entry    /// If tracking specification exists, they are retrieved from the tracking specification information    /// If there are assembly-to-order shipped not invoiced lines, they are retrieved from the assembly-to-order shipped not invoiced item ledger entry information    /// </summary>    /// <remarks>    /// If tracking specification doesn't exist, and there are no assembly-to-order shipped not invoiced lines, Item Entry Relation is assigned the Item Shipment Entry No. from the incoming Sales Shipment Line    /// </remarks>    /// <param name="ItemEntryRelation">Return value: Item Entry Relation related to the Item Entry</param>    /// <param name="SalesShptLine">Return value: Sales Shipment Line related to the Item Entry</param>    /// <param name="InvoicingTrackingSpecification">Tracking Specification for the Item Ledger Entry</param>    /// <param name="ItemLedgEntryNotInvoiced">An assemble-to-order Item Ledger Entry that is shipped, but not invoiced.</param>    /// <param name="TrackingSpecificationExists">Indicates whether the Item Ledger Entry has a Tracking Specification</param>    /// <param name="HasATOShippedNotInvoiced">Indicates whether there are Assembly-to-order Shipped Not Invoiced lines</param>    procedure SetItemEntryRelation(var ItemEntryRelation: Record "Item Entry Relation"; var SalesShptLine: Record "Sales Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; var ItemLedgEntryNotInvoiced: Record "Item Ledger Entry"; TrackingSpecificationExists: Boolean; HasATOShippedNotInvoiced: Boolean)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetItemEntryRelation(ItemEntryRelation, SalesShptLine, InvoicingTrackingSpecification, IsHandled);        if IsHandled then            exit;        if TrackingSpecificationExists then begin            ItemEntryRelation.Get(InvoicingTrackingSpecification."Item Ledger Entry No.");            SalesShptLine.Get(ItemEntryRelation."Source ID", ItemEntryRelation."Source Ref. No.");        end else            if HasATOShippedNotInvoiced then begin                ItemEntryRelation."Item Entry No." := ItemLedgEntryNotInvoiced."Entry No.";                SalesShptLine.Get(ItemLedgEntryNotInvoiced."Document No.", ItemLedgEntryNotInvoiced."Document Line No.");            end else                ItemEntryRelation."Item Entry No." := SalesShptLine."Item Shpt. Entry No.";    end;    local procedure PostATOAssocItemJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var PostedATOLink: Record "Posted Assemble-to-Order Link"; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal)    var        DummyTrackingSpecification: Record "Tracking Specification";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostATOAssocItemJnlLine(SalesHeader, SalesLine, PostedATOLink, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, ItemLedgShptEntryNo, IsHandled);        if IsHandled then            exit;        DummyTrackingSpecification.Init();        if SalesLine."Document Type" = SalesLine."Document Type"::Order then begin            PostedATOLink."Assembled Quantity" := -PostedATOLink."Assembled Quantity";            PostedATOLink."Assembled Quantity (Base)" := -PostedATOLink."Assembled Quantity (Base)";            if Abs(RemQtyToBeInvoiced) >= Abs(PostedATOLink."Assembled Quantity") then begin                ItemLedgShptEntryNo :=                  PostItemJnlLine(                    SalesHeader, SalesLine,                    PostedATOLink."Assembled Quantity", PostedATOLink."Assembled Quantity (Base)",                    PostedATOLink."Assembled Quantity", PostedATOLink."Assembled Quantity (Base)",                    0, '', DummyTrackingSpecification, true);                RemQtyToBeInvoiced -= PostedATOLink."Assembled Quantity";                RemQtyToBeInvoicedBase -= PostedATOLink."Assembled Quantity (Base)";            end else begin                if RemQtyToBeInvoiced <> 0 then                    ItemLedgShptEntryNo :=                      PostItemJnlLine(                        SalesHeader, SalesLine,                        RemQtyToBeInvoiced,                        RemQtyToBeInvoicedBase,                        RemQtyToBeInvoiced,                        RemQtyToBeInvoicedBase,                        0, '', DummyTrackingSpecification, true);                OnPostATOAssocItemJnlLineOnBeforeRemainingPost(                    SalesHeader, SalesLine, PostedATOLink, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, ItemLedgShptEntryNo);                ItemLedgShptEntryNo :=                  PostItemJnlLine(                    SalesHeader, SalesLine,                    PostedATOLink."Assembled Quantity" - RemQtyToBeInvoiced,                    PostedATOLink."Assembled Quantity (Base)" - RemQtyToBeInvoicedBase,                    0, 0,                    0, '', DummyTrackingSpecification, true);                RemQtyToBeInvoiced := 0;                RemQtyToBeInvoicedBase := 0;            end;        end;    end;    local procedure GetOpenLinkedATOs(var TempAsmHeader: Record "Assembly Header" temporary)    var        TempSalesLine: Record "Sales Line" temporary;        AsmHeader: Record "Assembly Header";    begin        ResetTempLines(TempSalesLine);        if TempSalesLine.FindSet() then            repeat                if TempSalesLine.AsmToOrderExists(AsmHeader) then                    if AsmHeader.Status = AsmHeader.Status::Open then begin                        TempAsmHeader.TransferFields(AsmHeader);                        TempAsmHeader.Insert();                    end;            until TempSalesLine.Next() = 0;    end;    local procedure ReopenAsmOrders(var TempAsmHeader: Record "Assembly Header" temporary)    var        AsmHeader: Record "Assembly Header";    begin        if TempAsmHeader.Find('-') then            repeat                AsmHeader.Get(TempAsmHeader."Document Type", TempAsmHeader."No.");                AsmHeader.Status := AsmHeader.Status::Open;                AsmHeader.Modify();            until TempAsmHeader.Next() = 0;    end;    local procedure InitPostATO(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")    var        AsmHeader: Record "Assembly Header";        Window: Dialog;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInitPostATO(SalesHeader, SalesLine, AsmPost, HideProgressWindow, IsHandled);        if IsHandled then            exit;        if SalesLine.AsmToOrderExists(AsmHeader) then begin            if GuiAllowed() and not HideProgressWindow then begin                Window.Open(AssemblyCheckProgressMsg);                Window.Update(1,                  StrSubstNo('%1 %2 %3 %4',                    SalesLine."Document Type", SalesLine."Document No.", SalesLine.FieldCaption("Line No."), SalesLine."Line No."));                Window.Update(2, StrSubstNo('%1 %2', AsmHeader."Document Type", AsmHeader."No."));            end;            SalesLine.CheckAsmToOrder(AsmHeader);            if not HasQtyToAsm(SalesLine, AsmHeader) then                exit;            AsmPost.SetSuppressCommit(SuppressCommit);            AsmPost.SetPostingDate(true, SalesHeader."Posting Date");            AsmPost.InitPostATO(AsmHeader);            if GuiAllowed() and not HideProgressWindow then                Window.Close();        end;    end;    local procedure InitPostATOs(SalesHeader: Record "Sales Header")    var        TempSalesLine: Record "Sales Line" temporary;    begin        FindNotShippedLines(SalesHeader, TempSalesLine);        TempSalesLine.SetFilter("Qty. to Assemble to Order", '<>0');        if TempSalesLine.FindSet() then            repeat                InitPostATO(SalesHeader, TempSalesLine);            until TempSalesLine.Next() = 0;    end;    local procedure PostATO(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary)    var        AsmHeader: Record "Assembly Header";        PostedATOLink: Record "Posted Assemble-to-Order Link";        Window: Dialog;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostATO(SalesHeader, SalesLine, TempPostedATOLink, AsmPost, ItemJnlPostLine, ResJnlPostLine, WhseJnlPostLine, HideProgressWindow, IsHandled);        if IsHandled then            exit;        if SalesLine.AsmToOrderExists(AsmHeader) then begin            if GuiAllowed() and not HideProgressWindow then begin                Window.Open(AssemblyPostProgressMsg);                Window.Update(1,                  StrSubstNo('%1 %2 %3 %4',                    SalesLine."Document Type", SalesLine."Document No.", SalesLine.FieldCaption("Line No."), SalesLine."Line No."));                Window.Update(2, StrSubstNo('%1 %2', AsmHeader."Document Type", AsmHeader."No."));            end;            SalesLine.CheckAsmToOrder(AsmHeader);            if not HasQtyToAsm(SalesLine, AsmHeader) then                exit;            if AsmHeader."Remaining Quantity (Base)" = 0 then                exit;            PostedATOLink.Init();            PostedATOLink."Assembly Document Type" := PostedATOLink."Assembly Document Type"::Assembly;            PostedATOLink."Assembly Document No." := AsmHeader."Posting No.";            PostedATOLink."Document Type" := PostedATOLink."Document Type"::"Sales Shipment";            PostedATOLink."Document No." := SalesHeader."Shipping No.";            PostedATOLink."Document Line No." := SalesLine."Line No.";            PostedATOLink."Assembly Order No." := AsmHeader."No.";            PostedATOLink."Order No." := SalesLine."Document No.";            PostedATOLink."Order Line No." := SalesLine."Line No.";            PostedATOLink."Assembled Quantity" := AsmHeader."Quantity to Assemble";            PostedATOLink."Assembled Quantity (Base)" := AsmHeader."Quantity to Assemble (Base)";            OnPostATOOnBeforePostedATOLinkInsert(PostedATOLink, AsmHeader, SalesLine);            PostedATOLink.Insert();            TempPostedATOLink := PostedATOLink;            TempPostedATOLink.Insert();            AsmPost.PostATO(AsmHeader, ItemJnlPostLine, ResJnlPostLine, WhseJnlPostLine);            if GuiAllowed() and not HideProgressWindow then                Window.Close();        end;    end;    local procedure FinalizePostATO(var SalesLine: Record "Sales Line")    var        ATOLink: Record "Assemble-to-Order Link";        AsmHeader: Record "Assembly Header";        Window: Dialog;        IsHandled: Boolean;    begin        OnBeforeFinalizePostATO(SalesLine, IsHandled);        if IsHandled then            exit;        if SalesLine.AsmToOrderExists(AsmHeader) then begin            if GuiAllowed() and not HideProgressWindow then begin                Window.Open(AssemblyFinalizeProgressMsg);                Window.Update(1,                  StrSubstNo('%1 %2 %3 %4',                    SalesLine."Document Type", SalesLine."Document No.", SalesLine.FieldCaption("Line No."), SalesLine."Line No."));                Window.Update(2, StrSubstNo('%1 %2', AsmHeader."Document Type", AsmHeader."No."));            end;            SalesLine.CheckAsmToOrder(AsmHeader);            AsmHeader.TestField("Remaining Quantity (Base)", 0);            AsmPost.FinalizePostATO(AsmHeader);            ATOLink.Get(AsmHeader."Document Type", AsmHeader."No.");            ATOLink.Delete();            if GuiAllowed() and not HideProgressWindow then                Window.Close();        end;    end;    local procedure CheckATOLink(SalesLine: Record "Sales Line")    var        AsmHeader: Record "Assembly Header";        IsHandled: Boolean;    begin        OnBeforeCheckATOLink(SalesLine, IsHandled);        if IsHandled then            exit;        if SalesLine."Qty. to Asm. to Order (Base)" = 0 then            exit;        if SalesLine.AsmToOrderExists(AsmHeader) then            SalesLine.CheckAsmToOrder(AsmHeader);    end;    local procedure DeleteATOLinks(SalesHeader: Record "Sales Header")    var        ATOLink: Record "Assemble-to-Order Link";        IsHandled: Boolean;    begin        OnBeforeDeleteATOLinks(SalesHeader, IsHandled);        if IsHandled then            exit;        ATOLink.SetCurrentKey(ATOLink.Type, ATOLink."Document Type", ATOLink."Document No.");        ATOLink.SetRange(ATOLink.Type, ATOLink.Type::Sale);        ATOLink.SetRange(ATOLink."Document Type", SalesHeader."Document Type");        ATOLink.SetRange(ATOLink."Document No.", SalesHeader."No.");        if not ATOLink.IsEmpty() then            ATOLink.DeleteAll();    end;    local procedure HasQtyToAsm(SalesLine: Record "Sales Line"; AsmHeader: Record "Assembly Header"): Boolean    begin        if SalesLine."Qty. to Asm. to Order (Base)" = 0 then            exit(false);        if SalesLine."Qty. to Ship (Base)" = 0 then            exit(false);        if AsmHeader."Quantity to Assemble (Base)" = 0 then            exit(false);        exit(true);    end;    local procedure GetATOItemLedgEntriesNotInvoiced(SalesLine: Record "Sales Line"; var ItemLedgEntryNotInvoiced: Record "Item Ledger Entry"): Boolean    var        PostedATOLink: Record "Posted Assemble-to-Order Link";        ItemLedgEntry: Record "Item Ledger Entry";    begin        ItemLedgEntryNotInvoiced.Reset();        ItemLedgEntryNotInvoiced.DeleteAll();        if PostedATOLink.FindLinksFromSalesLine(SalesLine) then            repeat                ItemLedgEntry.SetCurrentKey("Document No.", "Document Type", "Document Line No.");                ItemLedgEntry.SetRange("Document Type", ItemLedgEntry."Document Type"::"Sales Shipment");                ItemLedgEntry.SetRange("Document No.", PostedATOLink."Document No.");                ItemLedgEntry.SetRange("Document Line No.", PostedATOLink."Document Line No.");                ItemLedgEntry.SetRange("Assemble to Order", true);                ItemLedgEntry.SetRange("Completely Invoiced", false);                if ItemLedgEntry.FindSet() then                    repeat                        if ItemLedgEntry.Quantity <> ItemLedgEntry."Invoiced Quantity" then begin                            ItemLedgEntryNotInvoiced := ItemLedgEntry;                            OnGetATOItemLedgEntriesNotInvoicedOnBeforeItemLedgEntryNotInvoicedInsert(ItemLedgEntryNotInvoiced);                            ItemLedgEntryNotInvoiced.Insert();                        end;                    until ItemLedgEntry.Next() = 0;            until PostedATOLink.Next() = 0;        exit(ItemLedgEntryNotInvoiced.FindSet());    end;    /// <summary>    /// Sets the Warehouse Journal Register Line codeunit to the global variable    /// The codeunit is used when posting Warehouse Journal Lines, Assembly Orders and Warehouse Shipments    /// </summary>    /// <param name="WhseJnlRegisterLine">Warehouse Journal Register Line codeunit to be set</param>    procedure SetWhseJnlRegisterCU(var WhseJnlRegisterLine: Codeunit "Whse. Jnl.-Register Line")    begin        WhseJnlPostLine := WhseJnlRegisterLine;    end;    local procedure CheckPostWhseShptLines(var SalesShipmentLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line")    var        WarehouseShipmentLine: Record "Warehouse Shipment Line";        IsHandled: Boolean;        WhseShptLinesFound: Boolean;    begin        IsHandled := false;        OnBeforeCheckPostWhseShptLines(SalesShipmentLine, SalesLine, IsHandled, WhseShptHeader, WhseRcptHeader, WhseShip, WhseReceive);        if IsHandled then            exit;        if WhseShip then begin            WhseShptLinesFound :=                WarehouseShipmentLine.GetWhseShptLine(                    WhseShptHeader."No.", DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.");            OnCheckPostWhseShptLinesOnAfterWhseShptLinesFound(SalesShipmentLine, SalesLine, WhseShptLinesFound, WhseShptHeader, WhseRcptHeader, WhseShip, WhseReceive, WarehouseShipmentLine);            if WhseShptLinesFound then                PostWhseShptLines(WarehouseShipmentLine, SalesShipmentLine, SalesLine);        end;    end;    local procedure PostWhseShptLines(var WhseShptLine2: Record "Warehouse Shipment Line"; SalesShptLine2: Record "Sales Shipment Line"; var SalesLine2: Record "Sales Line")    var        ATOWhseShptLine: Record "Warehouse Shipment Line";        NonATOWhseShptLine: Record "Warehouse Shipment Line";        ATOLineFound: Boolean;        NonATOLineFound: Boolean;        TotalSalesShptLineQty: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostWhseShptLines(WhseShptLine2, SalesShptLine2, SalesLine2, IsHandled, PostedWhseShptHeader);        if IsHandled then            exit;        WhseShptLine2.GetATOAndNonATOLines(ATOWhseShptLine, NonATOWhseShptLine, ATOLineFound, NonATOLineFound);        if ATOLineFound then            TotalSalesShptLineQty += ATOWhseShptLine."Qty. to Ship";        if NonATOLineFound then            TotalSalesShptLineQty += NonATOWhseShptLine."Qty. to Ship";        SalesShptLine2.TestField(Quantity, TotalSalesShptLineQty);        SaveTempWhseSplitSpec(SalesLine2, TempATOTrackingSpecification);        WhsePostShpt.SetWhseJnlRegisterCU(WhseJnlPostLine);        if ATOLineFound and (ATOWhseShptLine."Qty. to Ship (Base)" > 0) then            WhsePostShpt.CreatePostedShptLine(              ATOWhseShptLine, PostedWhseShptHeader, PostedWhseShptLine, TempWhseSplitSpecification);        SaveTempWhseSplitSpec(SalesLine2, TempHandlingSpecification);        if NonATOLineFound and (NonATOWhseShptLine."Qty. to Ship (Base)" > 0) then            WhsePostShpt.CreatePostedShptLine(              NonATOWhseShptLine, PostedWhseShptHeader, PostedWhseShptLine, TempWhseSplitSpecification);    end;    local procedure GetCountryCode(SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"): Code[10]    var        SalesShipmentHeader: Record "Sales Shipment Header";        CountryRegionCode: Code[10];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetCountryCode(SalesHeader, SalesLine, CountryRegionCode, IsHandled);        if IsHandled then            exit(CountryRegionCode);        if SalesLine."Shipment No." <> '' then begin            SalesShipmentHeader.Get(SalesLine."Shipment No.");            exit(              GetCountryRegionCode(                SalesLine."Sell-to Customer No.",                SalesShipmentHeader."Ship-to Code",                SalesShipmentHeader."Sell-to Country/Region Code"));        end;        if SalesHeader.IsCreditDocType() then begin            if not SalesHeader.Receive then begin                if (SalesHeader."Ship-to Country/Region Code" <> '') then                    exit(SalesHeader."Ship-to Country/Region Code")                else                    exit(SalesHeader."Sell-to Country/Region Code");            end else begin                if (SalesHeader."Ship-to Country/Region Code" = '') and (SalesHeader."Rcvd.-from Count./Region Code" = '') then                    exit(SalesHeader."Sell-to Country/Region Code");                if SalesHeader."Rcvd.-from Count./Region Code" <> '' then                    exit(SalesHeader."Rcvd.-from Count./Region Code");                exit(SalesHeader."Ship-to Country/Region Code");            end;        end else begin            CountryRegionCode := SalesHeader."Ship-to Country/Region Code";            exit(              GetCountryRegionCode(                SalesLine."Sell-to Customer No.",                SalesHeader."Ship-to Code",                CountryRegionCode));        end;    end;    local procedure GetCountryRegionCode(CustNo: Code[20]; ShipToCode: Code[10]; SellToCountryRegionCode: Code[10]) Result: Code[10]    var        ShipToAddress: Record "Ship-to Address";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetCountryRegionCode(CustNo, ShipToCode, SellToCountryRegionCode, Result, IsHandled);        if IsHandled then            exit(Result);        if ShipToCode <> '' then begin            ShipToAddress.Get(CustNo, ShipToCode);            exit(ShipToAddress."Country/Region Code");        end;        exit(SellToCountryRegionCode);    end;    local procedure UpdateIncomingDocument(IncomingDocNo: Integer; PostingDate: Date; GenJnlLineDocNo: Code[20])    var        IncomingDocument: Record "Incoming Document";    begin        IncomingDocument.UpdateIncomingDocumentFromPosting(IncomingDocNo, PostingDate, GenJnlLineDocNo);    end;    local procedure CheckItemCharge(ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)")    var        SalesLineForCharge: Record "Sales Line";    begin        case ItemChargeAssgntSales."Applies-to Doc. Type" of            ItemChargeAssgntSales."Applies-to Doc. Type"::Order,              ItemChargeAssgntSales."Applies-to Doc. Type"::Invoice:                if SalesLineForCharge.Get(                     ItemChargeAssgntSales."Applies-to Doc. Type",                     ItemChargeAssgntSales."Applies-to Doc. No.",                     ItemChargeAssgntSales."Applies-to Doc. Line No.")                then                    if (SalesLineForCharge."Quantity (Base)" = SalesLineForCharge."Qty. Shipped (Base)") and                       (SalesLineForCharge."Qty. Shipped Not Invd. (Base)" = 0)                    then                        Error(ReassignItemChargeErr);            ItemChargeAssgntSales."Applies-to Doc. Type"::"Return Order",              ItemChargeAssgntSales."Applies-to Doc. Type"::"Credit Memo":                if SalesLineForCharge.Get(                     ItemChargeAssgntSales."Applies-to Doc. Type",                     ItemChargeAssgntSales."Applies-to Doc. No.",                     ItemChargeAssgntSales."Applies-to Doc. Line No.")                then                    if (SalesLineForCharge."Quantity (Base)" = SalesLineForCharge."Return Qty. Received (Base)") and                       (SalesLineForCharge."Ret. Qty. Rcd. Not Invd.(Base)" = 0)                    then                        Error(ReassignItemChargeErr);        end;    end;    local procedure CheckItemReservDisruption(SalesLine: Record "Sales Line")    var        ConfirmManagement: Codeunit "Confirm Management";        AvailableQty: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckItemReservDisruption(SalesLine, IsHandled);        if IsHandled then            exit;        if not (SalesLine."Document Type" in [SalesLine."Document Type"::Order, SalesLine."Document Type"::Invoice]) or           (SalesLine.Type <> SalesLine.Type::Item) or not (SalesLine."Qty. to Ship (Base)" > 0)        then            exit;        if (SalesLine."Job Contract Entry No." <> 0) or           SalesLine.Nonstock or SalesLine."Special Order" or SalesLine."Drop Shipment" or           SalesLine.FullQtyIsForAsmToOrder() or           TempSKU.Get(SalesLine."Location Code", SalesLine."No.", SalesLine."Variant Code")        then            exit;        if SalesLine.IsNonInventoriableItem() then            exit;        // For muliple sales order lines, the transaction acquires a lock on the reservation entry table while transfering reservervation entry for the first sales line to the item journal line. This locks the corresponding reserveration entries that are being modified.        // Therefore, using ReadUncommitted to calculate "Reserved Qty. on Inventory" will prevent unnecessary locking all the reservation entries for the item at a given location.        Item.SetRange("Location Filter", SalesLine."Location Code");        Item.SetRange("Variant Filter", SalesLine."Variant Code");        Item.ReadIsolation := IsolationLevel::ReadUncommitted;        Item.CalcFields("Reserved Qty. on Inventory");        if Item."Reserved Qty. on Inventory" <= 0 then            exit;        Item.ReadIsolation := IsolationLevel::Default;        Item.CalcFields("Net Change");        SalesLine.CalcFields("Reserved Qty. (Base)");        AvailableQty := Item."Net Change" - (Item."Reserved Qty. on Inventory" - SalesLine."Reserved Qty. (Base)");        if (AvailableQty < SalesLine."Qty. to Ship (Base)") and           (Item."Reserved Qty. on Inventory" > SalesLine."Reserved Qty. (Base)")        then begin            InsertTempSKU(SalesLine."Location Code", SalesLine."No.", SalesLine."Variant Code");            if Location.BinMandatory(SalesLine."Location Code") then begin                Session.LogMessage('0000GKN', ItemReservDisruptionLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', SalesLinePostCategoryTok);                if not ConfirmManagement.GetResponseOrDefault(                 StrSubstNo(                   ReservationDisruptedQst, SalesLine.FieldCaption("No."), Item."No.", SalesLine.FieldCaption("Location Code"),                   SalesLine."Location Code", SalesLine.FieldCaption("Variant Code"), SalesLine."Variant Code"), true)            then                    Error('');            end;        end;    end;    local procedure InsertTempSKU(LocationCode: Code[10]; ItemNo: Code[20]; VariantCode: Code[10])    begin        TempSKU.Init();        TempSKU."Location Code" := LocationCode;        TempSKU."Item No." := ItemNo;        TempSKU."Variant Code" := VariantCode;        TempSKU.Insert();    end;    /// <summary>    /// Initializes the progress window for posting with information about the sales header.    /// </summary>    /// <param name="SalesHeader">The sales header record for which the progress window is being initialized.</param>    procedure InitProgressWindow(SalesHeader: Record "Sales Header")    begin        if SalesHeader.Invoice then            Window.Open(              '#1#################################\\' +              PostingLinesMsg +              PostingSalesAndVATMsg +              PostingCustomersMsg +              PostingBalAccountMsg)        else            Window.Open(              '#1#################################\\' +              PostingLines2Msg);        Window.Update(1, StrSubstNo('%1 %2', SalesHeader."Document Type", SalesHeader."No."));    end;    local procedure CheckCertificateOfSupplyStatus(SalesShptHeader: Record "Sales Shipment Header"; SalesShptLine: Record "Sales Shipment Line")    var        CertificateOfSupply: Record "Certificate of Supply";        VATPostingSetup: Record "VAT Posting Setup";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckCertificateOfSupplyStatus(SalesShptHeader, SalesShptLine, IsHandled);        if IsHandled then            exit;        if SalesShptLine.Quantity <> 0 then            if VATPostingSetup.Get(SalesShptHeader."VAT Bus. Posting Group", SalesShptLine."VAT Prod. Posting Group") and               VATPostingSetup."Certificate of Supply Required"            then begin                CertificateOfSupply.InitFromSales(SalesShptHeader);                CertificateOfSupply.SetRequired(SalesShptHeader."No.");            end;    end;    local procedure InsertPostedHeaders(var SalesHeader: Record "Sales Header")    var        SalesShptLine: Record "Sales Shipment Line";        PurchRcptLine: Record "Purch. Rcpt. Line";        GenJnlLine: Record "Gen. Journal Line";        PostingPreviewEventHandler: Codeunit "Posting Preview Event Handler";        InsertShipmentHeaderNeeded: Boolean;        ShouldInsertInvoiceHeader: Boolean;        IsHandled: Boolean;    begin        if PreviewMode then            PostingPreviewEventHandler.PreventCommit();        OnBeforeInsertPostedHeaders(SalesHeader, TempWhseShptHeader, TempWhseRcptHeader);        // Insert shipment header        InsertShipmentHeaderNeeded := SalesHeader.Ship;        OnInsertPostedHeadersOnAfterCalcInsertShipmentHeaderNeeded(SalesHeader, TempWhseShptHeader, TempWhseRcptHeader, InsertShipmentHeaderNeeded);        if InsertShipmentHeaderNeeded then begin            if (SalesHeader."Document Type" = SalesHeader."Document Type"::Order) or                ((SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice) and SalesSetup."Shipment on Invoice")            then begin                if DropShipOrder then begin                    PurchRcptHeader.LockTable();                    PurchRcptLine.LockTable();                    SalesShptHeader.LockTable();                    SalesShptLine.LockTable();                end;                InsertShipmentHeader(SalesHeader, SalesShptHeader);            end;            OnInsertPostedHeadersOnAfterInsertShipmentHeader(SalesHeader);        end;        IsHandled := false;        OnInsertPostedHeadersOnBeforeDeleteServItemOnSaleCreditMemo(SalesHeader, SalesShptHeader, IsHandled);        if not IsHandled then            OnInsertPostedHeadersDeleteServItemOnSaleCreditMemo(SalesHeader);        // Insert return receipt header        CheckInsertReturnReceiptHeader(SalesHeader, ReturnRcptHeader);        IsHandled := false;        OnInsertPostedHeadersOnBeforeInsertInvoiceHeader(SalesHeader, IsHandled, SalesInvHeader, GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, InvoicePostingInterface);        if not IsHandled then            // Insert invoice header or credit memo header            if SalesHeader.Invoice then begin                ShouldInsertInvoiceHeader := SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice];                OnInsertPostedHeadersOnAfterCalcShouldInsertInvoiceHeader(SalesHeader, ShouldInsertInvoiceHeader);                if ShouldInsertInvoiceHeader then begin                    InsertInvoiceHeader(SalesHeader, SalesInvHeader);                    GenJnlLineDocType := GenJnlLine."Document Type"::Invoice;                    GenJnlLineDocNo := SalesInvHeader."No.";                    GenJnlLineExtDocNo := SalesInvHeader."External Document No.";                    OnInsertPostedHeadersOnAfterInsertInvoiceHeader(SalesHeader, SalesInvHeader);                end else begin // Credit Memo                    InsertCrMemoHeader(SalesHeader, SalesCrMemoHeader);                    GenJnlLineDocType := GenJnlLine."Document Type"::"Credit Memo";                    GenJnlLineDocNo := SalesCrMemoHeader."No.";                    GenJnlLineExtDocNo := SalesCrMemoHeader."External Document No.";                    OnInsertPostedHeadersOnAfterInsertCrMemoHeader(SalesHeader, SalesCrMemoHeader);                end;                GetInvoicePostingParameters();                InvoicePostingInterface.SetParameters(InvoicePostingParameters);            end;        OnAfterInsertPostedHeaders(SalesHeader, SalesShptHeader, SalesInvHeader, SalesCrMemoHeader, ReturnRcptHeader, GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo);    end;    local procedure InsertShipmentHeader(var SalesHeader: Record "Sales Header"; var SalesShptHeader: Record "Sales Shipment Header")    var        SalesCommentLine: Record "Sales Comment Line";        RecordLinkManagement: Codeunit "Record Link Management";    begin        SalesShptHeader.Init();        SalesHeader.CalcFields("Work Description");        OnInsertShipmentHeaderOnBeforeTransferfieldsToSalesShptHeader(SalesHeader);        SalesShptHeader.TransferFields(SalesHeader);        OnInsertShipmentHeaderOnAfterTransferfieldsToSalesShptHeader(SalesHeader, SalesShptHeader);        AssignPostedDocumentNo(SalesShptHeader."No.", SalesHeader."Shipping No.");        if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then begin            SalesShptHeader."Order No. Series" := SalesHeader."No. Series";            SalesShptHeader."Order No." := SalesHeader."No.";            if SalesSetup."Ext. Doc. No. Mandatory" then                SalesHeader.TestField("External Document No.");        end;        SalesShptHeader."Source Code" := SrcCode;        SalesShptHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(SalesShptHeader."User ID"));        SalesShptHeader."No. Printed" := 0;        SalesShptHeaderInsert(SalesShptHeader, SalesHeader);        ApprovalsMgmt.PostApprovalEntries(SalesHeader.RecordId, SalesShptHeader.RecordId, SalesShptHeader."No.");        if SalesSetup."Copy Comments Order to Shpt." then begin            SalesCommentLine.CopyComments(              SalesHeader."Document Type".AsInteger(), SalesCommentLine."Document Type"::Shipment.AsInteger(), SalesHeader."No.", SalesShptHeader."No.");            RecordLinkManagement.CopyLinks(SalesHeader, SalesShptHeader);        end;        if WhseShip then begin            WhseShptHeader.Get(TempWhseShptHeader."No.");            OnBeforeCreatePostedWhseShptHeader(PostedWhseShptHeader, WhseShptHeader, SalesHeader);            WhsePostShpt.CreatePostedShptHeader(PostedWhseShptHeader, WhseShptHeader, SalesHeader."Shipping No.", SalesHeader."Posting Date");        end;        if WhseReceive then begin            WhseRcptHeader.Get(TempWhseRcptHeader."No.");            OnBeforeCreatePostedWhseRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, SalesHeader);            WhsePostRcpt.CreatePostedRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, SalesHeader."Shipping No.", SalesHeader."Posting Date");        end;        OnAfterInsertShipmentHeader(SalesHeader, SalesShptHeader);    end;    local procedure CheckInsertReturnReceiptHeader(var SalesHeader: Record "Sales Header"; var ReturnRcptHeader: Record "Return Receipt Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckInsertReturnReceiptHeader(SalesHeader, IsHandled);        if IsHandled then            exit;        if SalesHeader.Receive then            if (SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order") or               ((SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo") and SalesSetup."Return Receipt on Credit Memo")            then                InsertReturnReceiptHeader(SalesHeader, ReturnRcptHeader);    end;    local procedure InsertReturnReceiptHeader(var SalesHeader: Record "Sales Header"; var ReturnRcptHeader: Record "Return Receipt Header")    var        SalesCommentLine: Record "Sales Comment Line";        RecordLinkManagement: Codeunit "Record Link Management";        IsHandled: Boolean;    begin        OnBeforeInsertReturnReceiptHeader(SalesHeader, ReturnRcptHeader, IsHandled, SuppressCommit);        if not IsHandled then begin            ReturnRcptHeader.Init();            OnInsertReturnReceiptHeaderOnBeforeReturnReceiptHeaderTransferFields(SalesHeader);            ReturnRcptHeader.TransferFields(SalesHeader);            AssignPostedDocumentNo(ReturnRcptHeader."No.", SalesHeader."Return Receipt No.");            if SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order" then begin                ReturnRcptHeader."Return Order No. Series" := SalesHeader."No. Series";                ReturnRcptHeader."Return Order No." := SalesHeader."No.";                if SalesSetup."Ext. Doc. No. Mandatory" then                    SalesHeader.TestField("External Document No.");            end;            ReturnRcptHeader."No. Series" := SalesHeader."Return Receipt No. Series";            ReturnRcptHeader."Source Code" := SrcCode;            ReturnRcptHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(ReturnRcptHeader."User ID"));            ReturnRcptHeader."No. Printed" := 0;            OnBeforeReturnRcptHeaderInsert(ReturnRcptHeader, SalesHeader, SuppressCommit, TempWhseRcptHeader, WhseReceive, TempWhseShptHeader, WhseShip);            ReturnRcptHeader.Insert(true);            OnAfterReturnRcptHeaderInsert(ReturnRcptHeader, SalesHeader, SuppressCommit, WhseShip, WhseReceive, TempWhseShptHeader, TempWhseRcptHeader);            ApprovalsMgmt.PostApprovalEntries(SalesHeader.RecordId, ReturnRcptHeader.RecordId, ReturnRcptHeader."No.");            if SalesSetup."Copy Cmts Ret.Ord. to Ret.Rcpt" then begin                SalesCommentLine.CopyComments(                  SalesHeader."Document Type".AsInteger(), SalesCommentLine."Document Type"::"Posted Return Receipt".AsInteger(), SalesHeader."No.", ReturnRcptHeader."No.");                RecordLinkManagement.CopyLinks(SalesHeader, ReturnRcptHeader);            end;        end;        if WhseReceive then begin            WhseRcptHeader.Get(TempWhseRcptHeader."No.");            OnBeforeCreatePostedWhseRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, SalesHeader);            WhsePostRcpt.CreatePostedRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, SalesHeader."Return Receipt No.", SalesHeader."Posting Date");        end;        if WhseShip then begin            WhseShptHeader.Get(TempWhseShptHeader."No.");            OnBeforeCreatePostedWhseShptHeader(PostedWhseShptHeader, WhseShptHeader, SalesHeader);            WhsePostShpt.CreatePostedShptHeader(PostedWhseShptHeader, WhseShptHeader, SalesHeader."Return Receipt No.", SalesHeader."Posting Date");        end;        OnAfterInsertReturnReceiptHeader(SalesHeader, ReturnRcptHeader);    end;    local procedure InsertInvoiceHeader(var SalesHeader: Record "Sales Header"; var SalesInvHeader: Record "Sales Invoice Header")    var        SalesCommentLine: Record "Sales Comment Line";        RecordLinkManagement: Codeunit "Record Link Management";        SegManagement: Codeunit SegManagement;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertInvoiceHeader(SalesHeader, SalesInvHeader, IsHandled);        if IsHandled then            exit;        SalesInvHeader.Init();        SalesHeader.CalcFields("Work Description");        OnInsertInvoiceHeaderOnBeforeSalesInvHeaderTransferFields(SalesHeader);        SalesInvHeader.TransferFields(SalesHeader);        OnInsertInvoiceHeaderOnAfterSalesInvHeaderTransferFields(SalesHeader, SalesInvHeader);        AssignPostedDocumentNo(SalesInvHeader."No.", SalesHeader."Posting No.");        IsHandled := false;        OnInsertInvoiceHeaderOnBeforeCheckDocumentType(SalesHeader, SalesInvHeader, SalesSetup, IsHandled);        if not IsHandled then            if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then begin                if SalesSetup."Ext. Doc. No. Mandatory" then                    SalesHeader.TestField("External Document No.");                SalesInvHeader."Pre-Assigned No. Series" := '';                SalesInvHeader."Order No. Series" := SalesHeader."No. Series";                SalesInvHeader."Order No." := SalesHeader."No.";            end else begin                if SalesHeader."Posting No." = '' then                    AssignPostedDocumentNo(SalesInvHeader."No.", SalesHeader."No.");                SalesInvHeader."Pre-Assigned No. Series" := SalesHeader."No. Series";                SalesInvHeader."Pre-Assigned No." := SalesHeader."No.";            end;        if GuiAllowed() and not HideProgressWindow then            Window.Update(1, StrSubstNo(InvoiceNoMsg, SalesHeader."Document Type", SalesHeader."No.", SalesInvHeader."No."));        SalesInvHeader."Source Code" := SrcCode;        SalesInvHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(SalesInvHeader."User ID"));        SalesInvHeader."No. Printed" := 0;        if SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice then            SalesInvHeader."Draft Invoice SystemId" := SalesHeader.SystemId;        SalesInvHeaderInsert(SalesInvHeader, SalesHeader);        UpdateWonOpportunities(SalesHeader);        SegManagement.CreateCampaignEntryOnSalesInvoicePosting(SalesInvHeader);        ApprovalsMgmt.PostApprovalEntries(SalesHeader.RecordId, SalesInvHeader.RecordId, SalesInvHeader."No.");        if SalesSetup."Copy Comments Order to Invoice" then begin            SalesCommentLine.CopyComments(              SalesHeader."Document Type".AsInteger(), SalesCommentLine."Document Type"::"Posted Invoice".AsInteger(), SalesHeader."No.", SalesInvHeader."No.");            RecordLinkManagement.CopyLinks(SalesHeader, SalesInvHeader);        end;        OnAfterInsertInvoiceHeader(SalesHeader, SalesInvHeader);    end;    local procedure InsertCrMemoHeader(var SalesHeader: Record "Sales Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header")    var        SalesCommentLine: Record "Sales Comment Line";        RecordLinkManagement: Codeunit "Record Link Management";        ShouldProcessAsReturnOrder: Boolean;    begin        SalesCrMemoHeader.Init();        SalesHeader.CalcFields("Work Description");        OnInsertCrMemoHeaderOnBeforeSalesCrMemoHeaderTransferFields(SalesHeader);        SalesCrMemoHeader.TransferFields(SalesHeader);        AssignPostedDocumentNo(SalesCrMemoHeader."No.", SalesHeader."No.");        OnInsertCrMemoHeaderOnAfterSalesCrMemoHeaderTransferFields(SalesHeader, SalesCrMemoHeader);        ShouldProcessAsReturnOrder := SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order";        OnInsertCrMemoHeaderOnAfterCalcShouldProcessAsReturnOrder(SalesHeader, ShouldProcessAsReturnOrder);        if ShouldProcessAsReturnOrder then begin            AssignPostedDocumentNo(SalesCrMemoHeader."No.", SalesHeader."Posting No.");            if SalesSetup."Ext. Doc. No. Mandatory" then                SalesHeader.TestField("External Document No.");            SalesCrMemoHeader."Pre-Assigned No. Series" := '';            SalesCrMemoHeader."Return Order No. Series" := SalesHeader."No. Series";            SalesCrMemoHeader."Return Order No." := SalesHeader."No.";            if GuiAllowed() and not HideProgressWindow then                Window.Update(1, StrSubstNo(CreditMemoNoMsg, SalesHeader."Document Type", SalesHeader."No.", SalesCrMemoHeader."No."));        end else begin            SalesCrMemoHeader."Pre-Assigned No. Series" := SalesHeader."No. Series";            SalesCrMemoHeader."Pre-Assigned No." := SalesHeader."No.";            if SalesHeader."Posting No." <> '' then begin                AssignPostedDocumentNo(SalesCrMemoHeader."No.", SalesHeader."Posting No.");                if GuiAllowed() and not HideProgressWindow then                    Window.Update(1, StrSubstNo(CreditMemoNoMsg, SalesHeader."Document Type", SalesHeader."No.", SalesCrMemoHeader."No."));            end;        end;        SalesCrMemoHeader."Source Code" := SrcCode;        SalesCrMemoHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(SalesCrMemoHeader."User ID"));        SalesCrMemoHeader."No. Printed" := 0;        SalesCrMemoHeader."Draft Cr. Memo SystemId" := SalesCrMemoHeader.SystemId;        SalesCrMemoHeaderInsert(SalesCrMemoHeader, SalesHeader);        ApprovalsMgmt.PostApprovalEntries(SalesHeader.RecordId, SalesCrMemoHeader.RecordId, SalesCrMemoHeader."No.");        if SalesSetup."Copy Cmts Ret.Ord. to Cr. Memo" then begin            SalesCommentLine.CopyComments(              SalesHeader."Document Type".AsInteger(), SalesCommentLine."Document Type"::"Posted Credit Memo".AsInteger(), SalesHeader."No.", SalesCrMemoHeader."No.");            RecordLinkManagement.CopyLinks(SalesHeader, SalesCrMemoHeader);        end;        OnAfterInsertCrMemoHeader(SalesHeader, SalesCrMemoHeader);    end;    local procedure InsertPurchRcptHeader(var PurchaseHeader: Record "Purchase Header"; var SalesHeader: Record "Sales Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header")    var        RunOnInsert: Boolean;    begin        PurchRcptHeader.Init();        PurchRcptHeader.TransferFields(PurchaseHeader);        AssignPostedDocumentNo(PurchRcptHeader."No.", PurchaseHeader."Receiving No.");        PurchRcptHeader."Order No." := PurchaseHeader."No.";        PurchRcptHeader."Posting Date" := SalesHeader."Posting Date";        PurchRcptHeader."Document Date" := SalesHeader."Document Date";        PurchRcptHeader."No. Printed" := 0;        RunOnInsert := false;        OnBeforePurchRcptHeaderInsert(PurchRcptHeader, PurchaseHeader, SalesHeader, SuppressCommit, RunOnInsert);        PurchRcptHeader.Insert(RunOnInsert);        OnAfterPurchRcptHeaderInsert(PurchRcptHeader, PurchaseHeader, SalesHeader, SuppressCommit);    end;    local procedure InsertPurchRcptLine(PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchOrderLine: Record "Purchase Line"; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer")    var        PurchRcptLine: Record "Purch. Rcpt. Line";    begin        PurchRcptLine.Init();        PurchRcptLine.TransferFields(PurchOrderLine);        PurchRcptLine."Posting Date" := PurchRcptHeader."Posting Date";        PurchRcptLine."Document No." := PurchRcptHeader."No.";        PurchRcptLine.Quantity := DropShptPostBuffer.Quantity;        PurchRcptLine."Quantity (Base)" := DropShptPostBuffer."Quantity (Base)";        PurchRcptLine."Quantity Invoiced" := 0;        PurchRcptLine."Qty. Invoiced (Base)" := 0;        PurchRcptLine."Order No." := PurchOrderLine."Document No.";        PurchRcptLine."Order Line No." := PurchOrderLine."Line No.";        PurchRcptLine."Qty. Rcd. Not Invoiced" := PurchRcptLine.Quantity - PurchRcptLine."Quantity Invoiced";        if PurchRcptLine.Quantity <> 0 then begin            PurchRcptLine."Item Rcpt. Entry No." := DropShptPostBuffer."Item Shpt. Entry No.";            PurchRcptLine."Item Charge Base Amount" := PurchOrderLine."Line Amount"        end;        PurchRcptLineInsert(PurchRcptLine, PurchRcptHeader, PurchOrderLine, DropShptPostBuffer);    end;    local procedure PurchRcptLineInsert(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchOrderLine: Record "Purchase Line"; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePurchRcptLineInsert(PurchRcptLine, PurchRcptHeader, PurchOrderLine, DropShptPostBuffer, SuppressCommit, TempSalesLineGlobal, IsHandled);        if IsHandled then            exit;        PurchRcptLine.Insert();        OnAfterPurchRcptLineInsert(PurchRcptLine, PurchRcptHeader, PurchOrderLine, DropShptPostBuffer, SuppressCommit, TempSalesLineGlobal);    end;    local procedure InsertShipmentLine(var SalesHeader: Record "Sales Header"; SalesShptHeader: Record "Sales Shipment Header"; SalesLine: Record "Sales Line"; CostBaseAmount: Decimal)    var        SalesShptLine: Record "Sales Shipment Line";        IsHandled: Boolean;        ShouldProcessShipmentRelation: Boolean;    begin        IsHandled := false;        OnBeforeInsertShipmentLine(SalesHeader, SalesLine, IsHandled);        if IsHandled then            exit;        SalesShptLine.InitFromSalesLine(SalesShptHeader, xSalesLine);        SalesShptLine."Quantity Invoiced" := -RemQtyToBeInvoiced;        SalesShptLine."Qty. Invoiced (Base)" := -RemQtyToBeInvoicedBase;        SalesShptLine."Qty. Shipped Not Invoiced" := SalesShptLine.Quantity - SalesShptLine."Quantity Invoiced";        OnInsertShipmentLineOnAfterInitQuantityFields(SalesLine, xSalesLine, SalesShptLine);        ShouldProcessShipmentRelation := (SalesLine.Type = SalesLine.Type::Item) and (SalesLine."Qty. to Ship" <> 0);        OnInsertShipmentLineOnAfterCalcShouldProcessShipmentRelation(SalesLine, ShouldProcessShipmentRelation);        if ShouldProcessShipmentRelation then begin            CheckPostWhseShptLines(SalesShptLine, SalesLine);            CheckPostWhseRcptLineFromShipmentLine(SalesLine, SalesShptLine);            SalesShptLine."Item Shpt. Entry No." :=              InsertShptEntryRelation(SalesHeader, SalesShptLine); // ItemLedgShptEntryNo            SalesShptLine."Item Charge Base Amount" :=              Round(CostBaseAmount / SalesLine.Quantity * SalesShptLine.Quantity);        end;        SalesShptLineInsert(SalesShptLine, SalesShptHeader, SalesLine, SalesHeader);        CheckCertificateOfSupplyStatus(SalesShptHeader, SalesShptLine);        OnInvoiceSalesShptLine(SalesShptLine, SalesInvHeader."No.", xSalesLine."Line No.", xSalesLine."Qty. to Invoice", SuppressCommit);        OnAfterInsertShipmentLine(SalesHeader, SalesLine, SalesShptLine, PreviewMode, xSalesLine);    end;    local procedure CheckPostWhseRcptLineFromShipmentLine(var SalesLine: Record "Sales Line"; var SalesShptLine: Record "Sales Shipment Line")    var        WhseRcptLine: Record "Warehouse Receipt Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckPostWhseRcptLineFromShipmentLine(SalesShptLine, SalesLine, IsHandled);        if IsHandled then            exit;        if WhseReceive then            if WhseRcptLine.GetWhseRcptLine(                 WhseRcptHeader."No.", DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.")            then                PostWhseRcptLineFromShipmentLine(WhseRcptLine, SalesLine, SalesShptLine);    end;    local procedure PostWhseRcptLineFromShipmentLine(var WhseRcptLine: Record "Warehouse Receipt Line"; var SalesLine: Record "Sales Line"; var SalesShptLine: Record "Sales Shipment Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostWhseRcptLineFromShipmentLine(WhseRcptLine, SalesShptLine, SalesLine, IsHandled, PostedWhseRcptHeader);        if IsHandled then            exit;        WhseRcptLine.TestField("Qty. to Receive", -SalesShptLine.Quantity);        SaveTempWhseSplitSpec(SalesLine, TempHandlingSpecification);        WhsePostRcpt.CreatePostedRcptLine(          WhseRcptLine, PostedWhseRcptHeader, PostedWhseRcptLine, TempWhseSplitSpecification);    end;    local procedure InsertReturnReceiptLine(ReturnRcptHeader: Record "Return Receipt Header"; SalesLine: Record "Sales Line"; CostBaseAmount: Decimal; var SalesHeader: Record "Sales Header")    var        ReturnRcptLine: Record "Return Receipt Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertReturnReceiptLine(SalesLine, ReturnRcptLine, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, IsHandled);        if not IsHandled then begin            ReturnRcptLine.InitFromSalesLine(ReturnRcptHeader, xSalesLine);            ReturnRcptLine."Quantity Invoiced" := RemQtyToBeInvoiced;            ReturnRcptLine."Qty. Invoiced (Base)" := RemQtyToBeInvoicedBase;            ReturnRcptLine."Return Qty. Rcd. Not Invd." := ReturnRcptLine.Quantity - ReturnRcptLine."Quantity Invoiced";            InsertReturnReceiptLineWhsePost(SalesLine, ReturnRcptHeader, ReturnRcptLine, CostBaseAmount);            OnBeforeReturnRcptLineInsert(ReturnRcptLine, ReturnRcptHeader, SalesLine, SuppressCommit, xSalesLine, TempSalesLineGlobal, SalesHeader);            ReturnRcptLine.Insert(true);        end;        OnAfterReturnRcptLineInsert(          ReturnRcptLine, ReturnRcptHeader, SalesLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit, SalesCrMemoHeader, TempWhseShptHeader, TempWhseRcptHeader, SalesHeader);    end;    local procedure InsertReturnReceiptLineWhsePost(var SalesLine: Record "Sales Line"; ReturnRcptHeader: Record "Return Receipt Header"; var ReturnRcptLine: Record "Return Receipt Line"; CostBaseAmount: Decimal)    var        WhseShptLine: Record "Warehouse Shipment Line";        WhseRcptLine: Record "Warehouse Receipt Line";        ShouldGetWhseRcptLine: Boolean;        ShouldGetWhseShptLine: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertReturnReceiptLineWhsePost(SalesLine, ReturnRcptHeader, WhseShip, WhseReceive, TempWhseRcptHeader, IsHandled,            ReturnRcptLine, xSalesLine, PostedWhseRcptHeader, WhseRcptHeader, CostBaseAmount);        if IsHandled then            exit;        if (SalesLine.Type = SalesLine.Type::Item) and (SalesLine."Return Qty. to Receive" <> 0) then begin            ShouldGetWhseRcptLine := WhseReceive and SalesLine.IsInventoriableItem();            OnInsertReturnReceiptLineWhsePostOnAfterCalcShouldGetWhseRcptLine(ReturnRcptLine, SalesLine, WhseShip, WhseReceive, ReturnRcptHeader, ShouldGetWhseRcptLine);            if ShouldGetWhseRcptLine then                if WhseRcptLine.GetWhseRcptLine(                     WhseRcptHeader."No.", DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.")                then begin                    WhseRcptLine.TestField("Qty. to Receive", ReturnRcptLine.Quantity);                    SaveTempWhseSplitSpec(SalesLine, TempHandlingSpecification);                    OnInsertReturnReceiptLineOnBeforeCreatePostedRcptLine(SalesLine, ReturnRcptLine, WhseRcptLine, PostedWhseRcptHeader);                    WhsePostRcpt.CreatePostedRcptLine(                      WhseRcptLine, PostedWhseRcptHeader, PostedWhseRcptLine, TempWhseSplitSpecification);                end;            ShouldGetWhseShptLine := WhseShip and SalesLine.IsInventoriableItem();            OnInsertReturnReceiptLineWhsePostOnAfterCalcShouldGetWhseShptLine(ReturnRcptLine, SalesLine, WhseShip, WhseReceive, ReturnRcptHeader, ShouldGetWhseShptLine);            if ShouldGetWhseShptLine then                if WhseShptLine.GetWhseShptLine(                     WhseShptHeader."No.", DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.")                then begin                    WhseShptLine.TestField("Qty. to Ship", -ReturnRcptLine.Quantity);                    SaveTempWhseSplitSpec(SalesLine, TempHandlingSpecification);                    WhsePostShpt.SetWhseJnlRegisterCU(WhseJnlPostLine);                    OnInsertReturnReceiptLineWhsePostOnBeforeCreatePostedShptLine(ReturnRcptLine, WhseShptLine, PostedWhseShptHeader);                    WhsePostShpt.CreatePostedShptLine(                      WhseShptLine, PostedWhseShptHeader, PostedWhseShptLine, TempWhseSplitSpecification);                end;            ReturnRcptLine."Item Rcpt. Entry No." :=              InsertReturnEntryRelation(ReturnRcptLine); // ItemLedgShptEntryNo;            ReturnRcptLine."Item Charge Base Amount" :=              Round(CostBaseAmount / SalesLine.Quantity * ReturnRcptLine.Quantity);        end;        OnAfterInsertReturnReceiptLineWhsePost(SalesLine, xSalesLine, ReturnRcptLine);    end;    local procedure CheckICPartnerBlocked(SalesHeader: Record "Sales Header")    var        ICPartner: Record "IC Partner";    begin        if SalesHeader."Sell-to IC Partner Code" <> '' then            if ICPartner.Get(SalesHeader."Sell-to IC Partner Code") then                ICPartner.TestField(Blocked, false);        if SalesHeader."Bill-to IC Partner Code" <> '' then            if ICPartner.Get(SalesHeader."Bill-to IC Partner Code") then                ICPartner.TestField(Blocked, false);    end;    local procedure SendICDocument(var SalesHeader: Record "Sales Header")    var        ICInboxOutboxMgt: Codeunit ICInboxOutboxMgt;        IsHandled: Boolean;        ModifyHeader: Boolean;    begin        IsHandled := false;        OnBeforeSendICDocument(SalesHeader, ModifyHeader, IsHandled);        if IsHandled then            exit;        if SalesHeader."Send IC Document" and (SalesHeader."IC Status" = SalesHeader."IC Status"::New) and (SalesHeader."IC Direction" = SalesHeader."IC Direction"::Outgoing) and            (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"])        then begin            SalesHeader.Modify();            ICInboxOutboxMgt.SendSalesDoc(SalesHeader, true);            SalesHeader.Get(SalesHeader."Document Type", SalesHeader."No.");            IsHandled := false;            OnSendICDocumentOnBeforeSetICStatus(SalesHeader, IsHandled);            if not IsHandled then                SalesHeader."IC Status" := SalesHeader."IC Status"::Pending;            ModifyHeader := true;        end;    end;    local procedure UpdateHandledICInboxTransaction(SalesHeader: Record "Sales Header")    var        HandledICInboxTrans: Record "Handled IC Inbox Trans.";        Customer: Record Customer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateHandledICInboxTransaction(SalesHeader, IsHandled);        if IsHandled then            exit;        if SalesHeader."IC Direction" = SalesHeader."IC Direction"::Incoming then begin            HandledICInboxTrans.SetRange("Document No.", SalesHeader."IC Reference Document No.");            Customer.Get(SalesHeader."Sell-to Customer No.");            HandledICInboxTrans.SetRange("IC Partner Code", Customer."IC Partner Code");            HandledICInboxTrans.LockTable();            if HandledICInboxTrans.FindFirst() then begin                HandledICInboxTrans.Status := HandledICInboxTrans.Status::Posted;                HandledICInboxTrans.Modify();            end;        end;    end;    local procedure RunItemJnlPostLine(var ItemJnlLineToPost: Record "Item Journal Line")    begin        ItemJnlPostLine.RunWithCheck(ItemJnlLineToPost);    end;    /// <summary>    /// Gets the posted document that was created from the specified sales header.    /// </summary>    /// <remarks>    /// Orders and Return Orders return Invoice or Credit Memo. If the Invoice or Credit Memo was not posted, the function does not return a value.    /// </remarks>    /// <param name="SalesHeader">The sales header for which to get the posted document.</param>    /// <param name="PostedSalesDocumentVariant">Return Variable: The posted document that was created from the specified sales header.</param>    procedure GetPostedDocumentRecord(SalesHeader: Record "Sales Header"; var PostedSalesDocumentVariant: Variant)    var        SalesShipmentHeader: Record "Sales Shipment Header";        SalesInvHeader: Record "Sales Invoice Header";        SalesCrMemoHeader: Record "Sales Cr.Memo Header";        ReturnReceiptHeader: Record "Return Receipt Header";        IsHandled: Boolean;    begin        case SalesHeader."Document Type" of            SalesHeader."Document Type"::Order:                begin                    if (not SalesHeader.Invoice) and (SalesHeader.Ship) then begin                        SalesShipmentHeader.Get(SalesHeader."Last Shipping No.");                        SalesShipmentHeader.SetRecFilter();                        PostedSalesDocumentVariant := SalesShipmentHeader;                    end;                    if SalesHeader.Invoice then begin                        SalesInvHeader.Get(SalesHeader."Last Posting No.");                        SalesInvHeader.SetRecFilter();                        PostedSalesDocumentVariant := SalesInvHeader;                    end;                end;            SalesHeader."Document Type"::Invoice:                begin                    if SalesHeader."Last Posting No." = '' then                        SalesInvHeader.Get(SalesHeader."No.")                    else                        SalesInvHeader.Get(SalesHeader."Last Posting No.");                    SalesInvHeader.SetRecFilter();                    PostedSalesDocumentVariant := SalesInvHeader;                end;            SalesHeader."Document Type"::"Credit Memo":                begin                    if SalesHeader."Last Posting No." = '' then                        SalesCrMemoHeader.Get(SalesHeader."No.")                    else                        SalesCrMemoHeader.Get(SalesHeader."Last Posting No.");                    SalesCrMemoHeader.SetRecFilter();                    PostedSalesDocumentVariant := SalesCrMemoHeader;                end;            SalesHeader."Document Type"::"Return Order":                begin                    if (not SalesHeader.Invoice) and (SalesHeader.Receive) then begin                        ReturnReceiptHeader.Get(SalesHeader."Last Return Receipt No.");                        ReturnReceiptHeader.SetRecFilter();                        PostedSalesDocumentVariant := ReturnReceiptHeader;                    end;                    if SalesHeader.Invoice then begin                        if SalesHeader."Last Posting No." = '' then                            SalesCrMemoHeader.Get(SalesHeader."No.")                        else                            SalesCrMemoHeader.Get(SalesHeader."Last Posting No.");                        SalesCrMemoHeader.SetRecFilter();                        PostedSalesDocumentVariant := SalesCrMemoHeader;                    end;                end;            else begin                IsHandled := false;                OnGetPostedDocumentRecordElseCase(SalesHeader, PostedSalesDocumentVariant, IsHandled);                if not IsHandled then                    Error(NotSupportedDocumentTypeErr, SalesHeader."Document Type");            end;        end;    end;    /// <summary>    /// Sends the posted document(s) that were created during posting to the specified Document Sending Profile.    /// </summary>    /// <remarks>    /// Send function in Document Sending Profile commits the transaction after it successfully sends the document.    /// </remarks>    /// <param name="SalesHeader">The sales header for which to find the documents to send.</param>    /// <param name="DocumentSendingProfile">The Document Sending Profile to use for sending the documents.</param>    procedure SendPostedDocumentRecord(SalesHeader: Record "Sales Header"; var DocumentSendingProfile: Record "Document Sending Profile")    var        SalesInvHeader: Record "Sales Invoice Header";        SalesCrMemoHeader: Record "Sales Cr.Memo Header";        SalesShipmentHeader: Record "Sales Shipment Header";        OfficeManagement: Codeunit "Office Management";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSendPostedDocumentRecord(SalesHeader, IsHandled, DocumentSendingProfile);        if IsHandled then            exit;        case SalesHeader."Document Type" of            SalesHeader."Document Type"::Order:                begin                    OnSendSalesDocument(SalesHeader.Invoice and SalesHeader.Ship, SuppressCommit);                    if SalesHeader.Invoice then begin                        SalesInvHeader.Get(SalesHeader."Last Posting No.");                        SalesInvHeader.SetRecFilter();                        SalesInvHeader.SendProfile(DocumentSendingProfile);                    end;                    if SalesHeader.Ship and SalesHeader.Invoice and not OfficeManagement.IsAvailable() then                        if not ConfirmDownloadShipment(SalesHeader) then                            exit;                    if SalesHeader.Ship then begin                        SalesShipmentHeader.Get(SalesHeader."Last Shipping No.");                        SalesShipmentHeader.SetRecFilter();                        SalesShipmentHeader.SendProfile(DocumentSendingProfile);                    end;                end;            SalesHeader."Document Type"::Invoice:                begin                    if SalesHeader."Last Posting No." = '' then                        SalesInvHeader.Get(SalesHeader."No.")                    else                        SalesInvHeader.Get(SalesHeader."Last Posting No.");                    SalesInvHeader.SetRecFilter();                    SalesInvHeader.SendProfile(DocumentSendingProfile);                end;            SalesHeader."Document Type"::"Credit Memo":                begin                    if SalesHeader."Last Posting No." = '' then                        SalesCrMemoHeader.Get(SalesHeader."No.")                    else                        SalesCrMemoHeader.Get(SalesHeader."Last Posting No.");                    SalesCrMemoHeader.SetRecFilter();                    SalesCrMemoHeader.SendProfile(DocumentSendingProfile);                end;            SalesHeader."Document Type"::"Return Order":                if SalesHeader.Invoice then begin                    if SalesHeader."Last Posting No." = '' then                        SalesCrMemoHeader.Get(SalesHeader."No.")                    else                        SalesCrMemoHeader.Get(SalesHeader."Last Posting No.");                    SalesCrMemoHeader.SetRecFilter();                    SalesCrMemoHeader.SendProfile(DocumentSendingProfile);                end;            else begin                IsHandled := false;                OnSendPostedDocumentRecordElseCase(SalesHeader, DocumentSendingProfile, IsHandled);                if not IsHandled then                    Error(NotSupportedDocumentTypeErr, SalesHeader."Document Type");            end;        end;    end;    local procedure ConfirmDownloadShipment(SalesHeader: Record "Sales Header") Result: Boolean    var        ConfirmManagement: Codeunit "Confirm Management";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeConfirmDownloadShipment(SalesHeader, Result, IsHandled);        if IsHandled then            exit(Result);        if ConfirmManagement.GetResponseOrDefault(SendShipmentAlsoQst, true) then            exit(true);        exit(false);    end;    local procedure MakeInventoryAdjustment()    var        InvtSetup: Record "Inventory Setup";        InvtAdjmtHandler: Codeunit "Inventory Adjustment Handler";        IsHandled: Boolean;    begin        InvtSetup.Get();        if InvtSetup.AutomaticCostAdjmtRequired() then begin            IsHandled := false;            OnBeforeMakeInventoryAdjustment(InvtSetup, InvtAdjmtHandler, IsHandled);            if not IsHandled then                InvtAdjmtHandler.MakeAutomaticInventoryAdjustment(ItemsToAdjust);        end;    end;    local procedure FindNotShippedLines(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeFindNotShippedLines(SalesHeader, TempSalesLine, IsHandled);        if IsHandled then            exit;        ResetTempLines(TempSalesLine);        TempSalesLine.SetFilter(Quantity, '<>0');        if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then            TempSalesLine.SetFilter("Qty. to Ship", '<>0');        TempSalesLine.SetRange("Shipment No.", '');        OnAfterFindNotShippedLines(SalesHeader, TempSalesLine);    end;    local procedure CheckTrackingAndWarehouseForShip(SalesHeader: Record "Sales Header") Ship: Boolean    var        TempSalesLine: Record "Sales Line" temporary;    begin        FindNotShippedLines(SalesHeader, TempSalesLine);        Ship := TempSalesLine.FindFirst();        WhseShip := TempWhseShptHeader.FindFirst();        WhseReceive := TempWhseRcptHeader.FindFirst();        OnCheckTrackingAndWarehouseForShipOnBeforeCheck(SalesHeader, TempWhseShptHeader, TempWhseRcptHeader, Ship, TempSalesLine);        if Ship then begin            CheckTrackingSpecification(SalesHeader, TempSalesLine);            if not (WhseShip or WhseReceive or InvtPickPutaway) then                CheckWarehouse(TempSalesLine);        end;        OnAfterCheckTrackingAndWarehouseForShip(SalesHeader, Ship, SuppressCommit, TempWhseShptHeader, TempWhseRcptHeader, TempSalesLine);        exit(Ship);    end;    local procedure CheckTrackingAndWarehouseForReceive(SalesHeader: Record "Sales Header") Receive: Boolean    var        TempSalesLine: Record "Sales Line" temporary;    begin        ResetTempLines(TempSalesLine);        TempSalesLine.SetFilter(Quantity, '<>0');        TempSalesLine.SetFilter("Return Qty. to Receive", '<>0');        TempSalesLine.SetRange("Return Receipt No.", '');        OnCheckTrackingAndWarehouseForReceiveOnAfterSetFilters(SalesHeader, TempSalesLine);        Receive := TempSalesLine.FindFirst();        WhseShip := TempWhseShptHeader.FindFirst();        WhseReceive := TempWhseRcptHeader.FindFirst();        OnCheckTrackingAndWarehouseForReceiveOnBeforeCheck(SalesHeader, TempWhseShptHeader, TempWhseRcptHeader, Receive);        if Receive then begin            CheckTrackingSpecification(SalesHeader, TempSalesLine);            if not (WhseReceive or WhseShip or InvtPickPutaway) then                CheckWarehouse(TempSalesLine);        end;        OnAfterCheckTrackingAndWarehouseForReceive(SalesHeader, Receive, SuppressCommit, TempWhseShptHeader, TempWhseRcptHeader, TempSalesLine);        exit(Receive);    end;    local procedure CheckIfInvPickExists(SalesHeader: Record "Sales Header"): Boolean    var        TempSalesLine: Record "Sales Line" temporary;        WarehouseActivityLine: Record "Warehouse Activity Line";    begin        FindNotShippedLines(SalesHeader, TempSalesLine);        if TempSalesLine.IsEmpty() then            exit(false);        TempSalesLine.FindSet();        repeat            if WarehouseActivityLine.ActivityExists(                    DATABASE::"Sales Line", TempSalesLine."Document Type".AsInteger(), TempSalesLine."Document No.", TempSalesLine."Line No.", 0,                    WarehouseActivityLine."Activity Type"::"Invt. Pick".AsInteger())            then                exit(true);        until TempSalesLine.Next() = 0;        exit(false);    end;    local procedure CheckIfInvPutawayExists(): Boolean    var        TempSalesLine: Record "Sales Line" temporary;        WarehouseActivityLine: Record "Warehouse Activity Line";    begin        ResetTempLines(TempSalesLine);        TempSalesLine.SetFilter(Quantity, '<>0');        TempSalesLine.SetFilter("Return Qty. to Receive", '<>0');        TempSalesLine.SetRange("Return Receipt No.", '');        if TempSalesLine.IsEmpty() then            exit(false);        TempSalesLine.FindSet();        repeat            if WarehouseActivityLine.ActivityExists(                    DATABASE::"Sales Line", TempSalesLine."Document Type".AsInteger(), TempSalesLine."Document No.", TempSalesLine."Line No.", 0,                    WarehouseActivityLine."Activity Type"::"Invt. Put-away".AsInteger())            then                exit(true);        until TempSalesLine.Next() = 0;        exit(false);    end;    local procedure FindTempItemChargeAssgntSales(SalesLineNo: Integer): Boolean    begin        ClearItemChargeAssgntFilter();        TempItemChargeAssgntSales.SetCurrentKey("Applies-to Doc. Type");        TempItemChargeAssgntSales.SetRange("Document Line No.", SalesLineNo);        exit(TempItemChargeAssgntSales.FindSet());    end;    local procedure UpdateInvoicedQtyOnShipmentLine(var SalesShptLine: Record "Sales Shipment Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    begin        OnBeforeUpdateInvoicedQtyOnShipmentLineProcedure(SalesShptLine, QtyToBeInvoiced, QtyToBeInvoicedBase);        SalesShptLine."Quantity Invoiced" := SalesShptLine."Quantity Invoiced" - QtyToBeInvoiced;        SalesShptLine."Qty. Invoiced (Base)" := SalesShptLine."Qty. Invoiced (Base)" - QtyToBeInvoicedBase;        SalesShptLine."Qty. Shipped Not Invoiced" := SalesShptLine.Quantity - SalesShptLine."Quantity Invoiced";        OnUpdateInvoicedQtyOnShipmentLineOnBeforeModifySalesShptLine(SalesShptLine, QtyToBeInvoiced, QtyToBeInvoicedBase);        SalesShptLine.Modify();    end;    /// <summary>    /// Sets the CalledBy global variable.    /// </summary>    /// <param name="NewCalledBy"></param>    procedure SetCalledBy(NewCalledBy: Integer)    begin        CalledBy := NewCalledBy;    end;    /// <summary>    /// Sets the Preview Mode for the current instance of the codeunit.    /// Preview Mode ensures no transactions are commited to the database and no documents are sent.    /// </summary>    /// <param name="NewPreviewMode">The new value for the Preview Mode.</param>    procedure SetPreviewMode(NewPreviewMode: Boolean)    begin        PreviewMode := NewPreviewMode;    end;    local procedure PostDropOrderShipment(var SalesHeader: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    var        PurchSetup: Record "Purchases & Payables Setup";        PurchCommentLine: Record "Purch. Comment Line";        PurchOrderHeader: Record "Purchase Header";        PurchOrderLine: Record "Purchase Line";        RecordLinkManagement: Codeunit "Record Link Management";    begin        OnBeforePostDropOrderShipment(SalesHeader, TempDropShptPostBuffer);        ArchivePurchaseOrders(TempDropShptPostBuffer);        if TempDropShptPostBuffer.FindSet() then begin            PurchSetup.Get();            repeat                PurchOrderHeader.Get(PurchOrderHeader."Document Type"::Order, TempDropShptPostBuffer."Order No.");                InsertPurchRcptHeader(PurchOrderHeader, SalesHeader, PurchRcptHeader);                ApprovalsMgmt.PostApprovalEntries(SalesHeader.RecordId, PurchRcptHeader.RecordId, PurchRcptHeader."No.");                if PurchSetup."Copy Comments Order to Receipt" then begin                    PurchCommentLine.CopyComments(                      PurchOrderHeader."Document Type".AsInteger(), PurchCommentLine."Document Type"::Receipt.AsInteger(),                      PurchOrderHeader."No.", PurchRcptHeader."No.");                    RecordLinkManagement.CopyLinks(PurchOrderHeader, PurchRcptHeader);                end;                TempDropShptPostBuffer.SetRange("Order No.", TempDropShptPostBuffer."Order No.");                repeat                    PurchOrderLine.Get(                      PurchOrderLine."Document Type"::Order,                      TempDropShptPostBuffer."Order No.", TempDropShptPostBuffer."Order Line No.");                    InsertPurchRcptLine(PurchRcptHeader, PurchOrderLine, TempDropShptPostBuffer);                    PurchPost.UpdateBlanketOrderLine(PurchOrderLine, true, false, false);                    OnPostDropOrderShipmentOnAfterUpdateBlanketOrderLine(                        PurchOrderHeader, PurchOrderLine, TempDropShptPostBuffer, SalesShptHeader, SalesHeader, PurchRcptHeader, TempTrackingSpecification, SrcCode);                until TempDropShptPostBuffer.Next() = 0;                TempDropShptPostBuffer.SetRange("Order No.");                OnAfterInsertDropOrderPurchRcptHeader(PurchRcptHeader);            until TempDropShptPostBuffer.Next() = 0;        end;        OnAfterPostDropOrderShipment(TempDropShptPostBuffer);    end;    local procedure PostItemTracking(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean)    var        QtyToInvoiceBaseInTrackingSpec: Decimal;        ShouldPostItemTrackingForReceipt: Boolean;        ShouldPostItemTrackingForShipment: Boolean;        ShouldProcessReceipt: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemTracking(SalesHeader, SalesLine, TrackingSpecificationExists, TempTrackingSpecification, IsHandled, TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced, PreciseTotalChargeAmt, RoundedPrevTotalChargeAmt, RemQtyToBeInvoiced, ItemJnlRollRndg);        if IsHandled then            exit;        if TrackingSpecificationExists then begin            TempTrackingSpecification.CalcSums("Qty. to Invoice (Base)");            QtyToInvoiceBaseInTrackingSpec := TempTrackingSpecification."Qty. to Invoice (Base)";            if not TempTrackingSpecification.FindFirst() then                TempTrackingSpecification.Init();        end;        ShouldProcessReceipt := SalesLine.IsCreditDocType();        OnPostItemTrackingOnAfterCalcShouldProcessReceipt(SalesHeader, SalesLine, ShouldProcessReceipt, ItemJnlRollRndg);        if ShouldProcessReceipt then begin            ShouldPostItemTrackingForReceipt :=                (Abs(RemQtyToBeInvoiced) > Abs(SalesLine."Return Qty. to Receive")) or                (Abs(RemQtyToBeInvoiced) >= Abs(QtyToInvoiceBaseInTrackingSpec)) and                (QtyToInvoiceBaseInTrackingSpec <> 0);            OnPostItemTrackingOnAfterCalcShouldPostItemTrackingForReceipt(                SalesHeader, SalesLine, RemQtyToBeInvoiced, QtyToInvoiceBaseInTrackingSpec, ShouldPostItemTrackingForReceipt);            if ShouldPostItemTrackingForReceipt then                PostItemTrackingForReceipt(                  SalesHeader, SalesLine, TrackingSpecificationExists, TempTrackingSpecification);            PostItemTrackingCheckReturnReceipt(SalesLine, RemQtyToBeInvoiced);        end else begin            ShouldPostItemTrackingForShipment :=                (Abs(RemQtyToBeInvoiced) > Abs(SalesLine."Qty. to Ship")) or                (Abs(RemQtyToBeInvoiced) >= Abs(QtyToInvoiceBaseInTrackingSpec)) and                (QtyToInvoiceBaseInTrackingSpec <> 0);            OnPostItemTrackingOnAfterCalcShouldPostItemTrackingForShipment(                SalesHeader, SalesLine, RemQtyToBeInvoiced, QtyToInvoiceBaseInTrackingSpec, ShouldPostItemTrackingForShipment);            if ShouldPostItemTrackingForShipment then                PostItemTrackingForShipment(                  SalesHeader, SalesLine, TrackingSpecificationExists, TempTrackingSpecification,                  TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced);            PostItemTrackingCheckShipment(SalesLine, RemQtyToBeInvoiced);        end;    end;    /// <summary>    /// Checks if remaining quantity to be invoiced is greater than the return quantity to be received. Throws an error if it is.    /// </summary>    /// <param name="SalesLine">The sales line to check.</param>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    procedure PostItemTrackingCheckReturnReceipt(SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemTrackingCheckReturnReceipt(SalesLine, RemQtyToBeInvoiced, IsHandled);        if IsHandled then            exit;        if Abs(RemQtyToBeInvoiced) > Abs(SalesLine."Return Qty. to Receive") then begin            if SalesLine."Document Type" = SalesLine."Document Type"::"Credit Memo" then                Error(InvoiceGreaterThanReturnReceiptErr, SalesLine."Return Receipt No.");            Error(ReturnReceiptLinesDeletedErr);        end;    end;    /// <summary>    /// Checks if remaining quantity to be invoiced is greater than the quantity to be shipped. Throws an error if it is    /// </summary>    /// <param name="SalesLine">The sales line to check.</param>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    procedure PostItemTrackingCheckShipment(SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemTrackingCheckShipment(SalesLine, RemQtyToBeInvoiced, IsHandled);        if IsHandled then            exit;        if Abs(RemQtyToBeInvoiced) > Abs(SalesLine."Qty. to Ship") then begin            if SalesLine."Document Type" = SalesLine."Document Type"::Invoice then                Error(QuantityToInvoiceGreaterErr, SalesLine."Shipment No.");            Error(ShipmentLinesDeletedErr);        end;    end;    /// <summary>    /// Posts item tracking for return receipt lines during invoicing.    /// </summary>    /// <param name="SalesHeader">The sales header record.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="TrackingSpecificationExists">Indicates if tracking specification exists.</param>    /// <param name="TempTrackingSpecification">Temporary tracking specification records.</param>    procedure PostItemTrackingForReceipt(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary)    var        ItemEntryRelation: Record "Item Entry Relation";        ReturnRcptLine: Record "Return Receipt Line";        SalesShptLine: Record "Sales Shipment Line";        EndLoop: Boolean;        QtyToBeInvoiced: Decimal;        QtyToBeInvoicedBase: Decimal;        ShouldAdjustQuantityRounding: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemTrackingForReceipt(SalesLine, IsHandled);        if IsHandled then            exit;        EndLoop := false;        ReturnRcptLine.Reset();        case SalesHeader."Document Type" of            SalesHeader."Document Type"::"Return Order":                begin                    ReturnRcptLine.SetCurrentKey("Return Order No.", "Return Order Line No.");                    ReturnRcptLine.SetRange("Return Order No.", SalesLine."Document No.");                    ReturnRcptLine.SetRange("Return Order Line No.", SalesLine."Line No.");                end;            SalesHeader."Document Type"::"Credit Memo":                begin                    ReturnRcptLine.SetRange("Document No.", SalesLine."Return Receipt No.");                    ReturnRcptLine.SetRange("Line No.", SalesLine."Return Receipt Line No.");                end;        end;        ReturnRcptLine.SetFilter("Return Qty. Rcd. Not Invd.", '<>0');        OnPostItemTrackingForReceiptOnAfterSetFilters(ReturnRcptLine, SalesHeader, SalesLine);        if ReturnRcptLine.FindSet() then begin            ItemJnlRollRndg := true;            repeat                GetReturnRcptLineFromTrackingOrUpdateItemEntryRelation(                    SalesHeader, TrackingSpecificationExists, ItemEntryRelation, TempTrackingSpecification, ReturnRcptLine);                UpdateChargeItemReturnRcptLineGenProdPostingGroup(ReturnRcptLine);                CheckReturnRcptLine(ReturnRcptLine, SalesLine);                if SalesLine."Qty. to Invoice" * ReturnRcptLine.Quantity < 0 then                    SalesLine.FieldError("Qty. to Invoice", ReturnReceiptSameSignErr);                UpdateQtyToBeInvoicedForReturnReceipt(                  QtyToBeInvoiced, QtyToBeInvoicedBase,                  TrackingSpecificationExists, SalesLine, ReturnRcptLine, TempTrackingSpecification);                if TrackingSpecificationExists then begin                    TempTrackingSpecification."Quantity actual Handled (Base)" := QtyToBeInvoicedBase;                    TempTrackingSpecification.Modify();                end;                ShouldAdjustQuantityRounding := TrackingSpecificationExists;                OnPostItemTrackingForReceiptOnBeforeAdjustQuantityRounding(                    ReturnRcptLine, RemQtyToBeInvoiced, QtyToBeInvoiced, RemQtyToBeInvoicedBase, QtyToBeInvoicedBase,                    TrackingSpecificationExists, ShouldAdjustQuantityRounding);                if ShouldAdjustQuantityRounding then                    ItemTrackingMgt.AdjustQuantityRounding(                      RemQtyToBeInvoiced, QtyToBeInvoiced,                      RemQtyToBeInvoicedBase, QtyToBeInvoicedBase);                RemQtyToBeInvoiced := RemQtyToBeInvoiced - QtyToBeInvoiced;                RemQtyToBeInvoicedBase := RemQtyToBeInvoicedBase - QtyToBeInvoicedBase;                ReturnRcptLine."Quantity Invoiced" :=                  ReturnRcptLine."Quantity Invoiced" + QtyToBeInvoiced;                ReturnRcptLine."Qty. Invoiced (Base)" :=                  ReturnRcptLine."Qty. Invoiced (Base)" + QtyToBeInvoicedBase;                ReturnRcptLine."Return Qty. Rcd. Not Invd." :=                  ReturnRcptLine.Quantity - ReturnRcptLine."Quantity Invoiced";                IsHandled := false;                OnPostItemTrackingForReceiptOnBeforeReturnRcptLineModify(SalesHeader, ReturnRcptLine, SalesLine, IsHandled);                if not IsHandled then                    ReturnRcptLine.Modify();                OnBeforePostItemTrackingReturnRcpt(                  SalesInvHeader, SalesShptLine, TempTrackingSpecification, TrackingSpecificationExists,                  SalesCrMemoHeader, ReturnRcptLine, SalesLine, QtyToBeInvoiced, QtyToBeInvoicedBase);                if PostItemTrackingForReceiptCondition(SalesLine, ReturnRcptLine) then                    PostItemJnlLine(                      SalesHeader, SalesLine, 0, 0, QtyToBeInvoiced, QtyToBeInvoicedBase,                      ItemEntryRelation."Item Entry No.", '', TempTrackingSpecification, false);                OnAfterPostItemTrackingReturnRcpt(                  SalesInvHeader, SalesShptLine, TempTrackingSpecification, TrackingSpecificationExists,                  SalesCrMemoHeader, ReturnRcptLine, SalesLine, QtyToBeInvoiced, QtyToBeInvoicedBase);                EndLoop := IsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced, TrackingSpecificationExists, ReturnRcptLine, TempTrackingSpecification, SalesLine);            until EndLoop;        end else begin            IsHandled := false;            OnPostItemTrackingForShipmentOnBeforeReturnReceiptInvoiceErr(SalesLine, IsHandled, SalesHeader, ItemJnlRollRndg, TrackingSpecificationExists, TempTrackingSpecification, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase);            if not IsHandled then                Error(                  ReturnReceiptInvoicedErr,                  SalesLine."Return Receipt Line No.", SalesLine."Return Receipt No.");        end;    end;    local procedure CheckReturnRcptLine(var ReturnReceiptLine: Record "Return Receipt Line"; SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckReturnRcptLine(ReturnReceiptLine, SalesLine, IsHandled);        if IsHandled then            exit;        ReturnReceiptLine.TestField("Sell-to Customer No.", SalesLine."Sell-to Customer No.");        ReturnReceiptLine.TestField(Type, SalesLine.Type);        ReturnReceiptLine.TestField("No.", SalesLine."No.");        ReturnReceiptLine.TestField("Gen. Bus. Posting Group", SalesLine."Gen. Bus. Posting Group");        ReturnReceiptLine.TestField("Gen. Prod. Posting Group", SalesLine."Gen. Prod. Posting Group");        ReturnReceiptLine.TestField("Job No.", SalesLine."Job No.");        ReturnReceiptLine.TestField("Unit of Measure Code", SalesLine."Unit of Measure Code");        ReturnReceiptLine.TestField("Variant Code", SalesLine."Variant Code");    end;    local procedure IsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var ReturnReceiptLine: Record "Return Receipt Line"; var TempTrackingSpecification: Record "Tracking Specification"; SalesLine: Record "Sales Line") EndLoop: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeIsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced, TrackingSpecificationExists, ReturnReceiptLine, TempTrackingSpecification, SalesLine, EndLoop, IsHandled);        if IsHandled then            exit;        if TrackingSpecificationExists then            exit((TempTrackingSpecification.Next() = 0) or (RemQtyToBeInvoiced = 0));        exit((ReturnReceiptLine.Next() = 0) or (Abs(RemQtyToBeInvoiced) <= Abs(SalesLine."Return Qty. to Receive")));    end;    local procedure GetItemEntryRelation(var SalesHeader: Record "Sales Header"; var ItemEntryRelation: Record "Item Entry Relation"; var TempTrackingSpecification: Record "Tracking Specification" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetItemEntryRelation(SalesHeader, ItemEntryRelation, TempTrackingSpecification, IsHandled);        if IsHandled then            exit;        ItemEntryRelation.Get(TempTrackingSpecification."Item Ledger Entry No.");    end;    local procedure GetReturnRcptLineFromTrackingOrUpdateItemEntryRelation(SalesHeader: Record "Sales Header"; TrackingSpecificationExists: Boolean; var ItemEntryRelation: Record "Item Entry Relation"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var ReturnRcptLine: Record "Return Receipt Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetReturnRcptLineFromTrackingOrUpdateItemEntryRelation(TempTrackingSpecification, ReturnRcptLine, ItemEntryRelation, IsHandled, TrackingSpecificationExists);        if IsHandled then            exit;        if TrackingSpecificationExists then begin  // Item Tracking            GetItemEntryRelation(SalesHeader, ItemEntryRelation, TempTrackingSpecification);            ReturnRcptLine.Get(ItemEntryRelation."Source ID", ItemEntryRelation."Source Ref. No.");        end else            ItemEntryRelation."Item Entry No." := ReturnRcptLine."Item Rcpt. Entry No.";    end;    local procedure PostItemTrackingForReceiptCondition(SalesLine: Record "Sales Line"; ReturnRcptLine: Record "Return Receipt Line"): Boolean    var        Condition: Boolean;    begin        Condition := SalesLine.Type = SalesLine.Type::Item;        OnBeforePostItemTrackingForReceiptCondition(SalesLine, ReturnRcptLine, Condition);        exit(Condition);    end;    /// <summary>    /// Posts item tracking entries for shipments during invoice posting.    /// Processes shipment lines that have been shipped but not yet invoiced, applying item tracking and updating invoiced quantities.    /// </summary>    /// <param name="SalesHeader">The sales header record.</param>    /// <param name="SalesLine">The sales line record being invoiced.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists for the line.</param>    /// <param name="TempTrackingSpecification">Temporary tracking specification records.</param>    /// <param name="TempItemLedgEntryNotInvoiced">Temporary item ledger entries that have not been invoiced.</param>    /// <param name="HasATOShippedNotInvoiced">Indicates whether there are assemble-to-order items shipped but not invoiced.</param>    procedure PostItemTrackingForShipment(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean)    var        ItemEntryRelation: Record "Item Entry Relation";        SalesShptLine: Record "Sales Shipment Line";        RemQtyToInvoiceCurrLine: Decimal;        RemQtyToInvoiceCurrLineBase: Decimal;        QtyToBeInvoiced: Decimal;        QtyToBeInvoicedBase: Decimal;        ShouldAdjustQuantityRounding: Boolean;        IsHandled: Boolean;    begin        SalesShptLine.Reset();        case SalesHeader."Document Type" of            SalesHeader."Document Type"::Order:                begin                    SalesShptLine.SetCurrentKey("Order No.", "Order Line No.");                    SalesShptLine.SetRange("Order No.", SalesLine."Document No.");                    SalesShptLine.SetRange("Order Line No.", SalesLine."Line No.");                end;            SalesHeader."Document Type"::Invoice:                begin                    SalesShptLine.SetRange("Document No.", SalesLine."Shipment No.");                    SalesShptLine.SetRange("Line No.", SalesLine."Shipment Line No.");                end;        end;        IsHandled := false;        OnPostItemTrackingForShipmentOnBeforeGetATOItemLedgEntriesNotInvoiced(SalesHeader, IsHandled);        if not IsHandled then            if not TrackingSpecificationExists then                HasATOShippedNotInvoiced := GetATOItemLedgEntriesNotInvoiced(SalesLine, TempItemLedgEntryNotInvoiced);        SalesShptLine.SetFilter("Qty. Shipped Not Invoiced", '<>0');        OnPostItemTrackingForShipmentOnAfterSetFilters(SalesShptLine, SalesHeader, SalesLine);        if SalesShptLine.FindFirst() then begin            ItemJnlRollRndg := true;            repeat                SetItemEntryRelation(                  ItemEntryRelation, SalesShptLine,                  TempTrackingSpecification, TempItemLedgEntryNotInvoiced,                  TrackingSpecificationExists, HasATOShippedNotInvoiced);                UpdateRemainingQtyToBeInvoiced(SalesShptLine, RemQtyToInvoiceCurrLine, RemQtyToInvoiceCurrLineBase);                UpdateChargeItemSalesShptLineGenProdPostingGroup(SalesShptLine);                OnPostItemTrackingForShipmentOnAfterUpdateSalesShptLineFields(SalesShptLine, SalesLine);                IsHandled := false;                OnPostItemTrackingForShipmentOnBeforeTestLineFields(SalesShptLine, SalesLine, IsHandled);                if not IsHandled then begin                    SalesShptLine.TestField("Sell-to Customer No.", SalesLine."Sell-to Customer No.");                    SalesShptLine.TestField(Type, SalesLine.Type);                    SalesShptLine.TestField("No.", SalesLine."No.");                    SalesShptLine.TestField("Gen. Bus. Posting Group", SalesLine."Gen. Bus. Posting Group");                    SalesShptLine.TestField("Gen. Prod. Posting Group", SalesLine."Gen. Prod. Posting Group");                    CheckJobNoOnShptLineEqualToSales(SalesShptLine, SalesLine);                    SalesShptLine.TestField("Unit of Measure Code", SalesLine."Unit of Measure Code");                    SalesShptLine.TestField("Variant Code", SalesLine."Variant Code");                end;                if -SalesLine."Qty. to Invoice" * SalesShptLine.Quantity < 0 then                    SalesLine.FieldError("Qty. to Invoice", ShipmentSameSignErr);                UpdateQtyToBeInvoicedForShipment(                  QtyToBeInvoiced, QtyToBeInvoicedBase,                  TrackingSpecificationExists, HasATOShippedNotInvoiced,                  SalesLine, SalesShptLine,                  TempTrackingSpecification, TempItemLedgEntryNotInvoiced);                if TrackingSpecificationExists then begin                    TempTrackingSpecification."Quantity actual Handled (Base)" := QtyToBeInvoicedBase;                    TempTrackingSpecification.Modify();                end;                ShouldAdjustQuantityRounding := TrackingSpecificationExists or HasATOShippedNotInvoiced;                OnPostItemTrackingForShipmentOnBeforeAdjustQuantityRounding(                    SalesShptLine, RemQtyToInvoiceCurrLine, QtyToBeInvoiced, RemQtyToInvoiceCurrLineBase, QtyToBeInvoicedBase,                    TrackingSpecificationExists, HasATOShippedNotInvoiced, ShouldAdjustQuantityRounding);                if ShouldAdjustQuantityRounding then                    ItemTrackingMgt.AdjustQuantityRounding(                      RemQtyToInvoiceCurrLine, QtyToBeInvoiced,                      RemQtyToInvoiceCurrLineBase, QtyToBeInvoicedBase);                RemQtyToBeInvoiced := RemQtyToBeInvoiced - QtyToBeInvoiced;                RemQtyToBeInvoicedBase := RemQtyToBeInvoicedBase - QtyToBeInvoicedBase;                OnBeforeUpdateInvoicedQtyOnShipmentLine(SalesShptLine, SalesLine, SalesHeader, SalesInvHeader, SuppressCommit);                UpdateInvoicedQtyOnShipmentLine(SalesShptLine, QtyToBeInvoiced, QtyToBeInvoicedBase);                OnInvoiceSalesShptLine(SalesShptLine, SalesInvHeader."No.", SalesLine."Line No.", -QtyToBeInvoiced, SuppressCommit);                OnBeforePostItemTrackingForShipment(                  SalesInvHeader, SalesShptLine, TempTrackingSpecification, TrackingSpecificationExists, SalesLine,                  QtyToBeInvoiced, QtyToBeInvoicedBase);                if PostItemTrackingForShipmentCondition(SalesLine, SalesShptLine) then                    PostItemJnlLine(                      SalesHeader, SalesLine, 0, 0, QtyToBeInvoiced, QtyToBeInvoicedBase,                      ItemEntryRelation."Item Entry No.", '', TempTrackingSpecification, false);                OnAfterPostItemTrackingForShipment(                  SalesInvHeader, SalesShptLine, TempTrackingSpecification, TrackingSpecificationExists, SalesLine,                  QtyToBeInvoiced, QtyToBeInvoicedBase);            until IsEndLoopForShippedNotInvoiced(                    RemQtyToBeInvoiced, TrackingSpecificationExists, HasATOShippedNotInvoiced,                    SalesShptLine, TempTrackingSpecification, TempItemLedgEntryNotInvoiced, SalesLine);        end else begin            IsHandled := false;            OnPostItemTrackingForShipmentOnBeforeShipmentInvoiceErr(SalesLine, IsHandled, SalesHeader, ItemJnlRollRndg, TrackingSpecificationExists, TempTrackingSpecification, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase);            if not IsHandled then                Error(                  ShipmentInvoiceErr, SalesLine."Shipment Line No.", SalesLine."Shipment No.");        end;    end;    local procedure CheckJobNoOnShptLineEqualToSales(SalesShipmentLine: Record "Sales Shipment Line"; SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckJobNoOnShptLineEqualToSales(SalesShipmentLine, SalesLine, IsHandled);        if IsHandled then            exit;        SalesShipmentLine.TestField("Job No.", SalesLine."Job No.");    end;    local procedure PostItemTrackingForShipmentCondition(SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"): Boolean    var        Condition: Boolean;    begin        Condition := SalesLine.Type = SalesLine.Type::Item;        OnBeforePostItemTrackingForShipmentCondition(SalesLine, SalesShptLine, Condition);        exit(Condition);    end;    /// <summary>    /// Updates order lines after posting by adjusting shipped, received, and invoiced quantities.    /// Also handles prepayment deductions, blanket order updates, and resets quantities for the next posting.    /// </summary>    /// <param name="SalesHeader">The sales header record that was posted.</param>    procedure PostUpdateOrderLine(SalesHeader: Record "Sales Header")    var        TempSalesLine: Record "Sales Line" temporary;        SetDefaultQtyBlank: Boolean;        IsHandled: Boolean;        ShouldCalcPrepmtAmounts: Boolean;        ShouldSetInvoiceFields: Boolean;    begin        OnBeforePostUpdateOrderLine(SalesHeader, TempSalesLineGlobal, SuppressCommit, SalesSetup);        ResetTempLines(TempSalesLine);        TempSalesLine.SetRange("Prepayment Line", false);        TempSalesLine.SetFilter(Quantity, '<>0');        OnPostUpdateOrderLineOnAfterSetFilters(TempSalesLine);        if TempSalesLine.FindSet() then            repeat                OnPostUpdateOrderLineOnBeforeInitTempSalesLineQuantities(SalesHeader, TempSalesLine);                if SalesHeader.Ship then begin                    IsHandled := false;                    OnPostUpdateOrderLineOnBeforeGetQuantityShipped(TempSalesLine, IsHandled, SalesHeader);                    if not IsHandled then begin                        TempSalesLine."Quantity Shipped" += TempSalesLine."Qty. to Ship";                        TempSalesLine."Qty. Shipped (Base)" += TempSalesLine."Qty. to Ship (Base)";                    end;                end;                if SalesHeader.Receive then begin                    IsHandled := false;                    OnPostUpdateOrderLineOnBeforeGetReturnQtyReceived(TempSalesLine, IsHandled, SalesHeader);                    if not IsHandled then begin                        TempSalesLine."Return Qty. Received" += TempSalesLine."Return Qty. to Receive";                        TempSalesLine."Return Qty. Received (Base)" += TempSalesLine."Return Qty. to Receive (Base)";                    end;                end;                ShouldSetInvoiceFields := SalesHeader.Invoice;                OnPostUpdateOrderLineOnBeforeSetInvoiceFields(SalesHeader, TempSalesLine, ShouldSetInvoiceFields);                if ShouldSetInvoiceFields then begin                    IsHandled := false;                    OnPostUpdateOrderLineOnBeforeUpdateInvoicedValues(SalesHeader, TempSalesLine, IsHandled);                    if not IsHandled then begin                        if TempSalesLine."Document Type" = TempSalesLine."Document Type"::Order then begin                            if Abs(TempSalesLine."Quantity Invoiced" + TempSalesLine."Qty. to Invoice") > Abs(TempSalesLine."Quantity Shipped") then begin                                TempSalesLine.Validate(TempSalesLine."Qty. to Invoice", TempSalesLine."Quantity Shipped" - TempSalesLine."Quantity Invoiced");                                TempSalesLine."Qty. to Invoice (Base)" := TempSalesLine."Qty. Shipped (Base)" - TempSalesLine."Qty. Invoiced (Base)";                            end                        end else                            if Abs(TempSalesLine."Quantity Invoiced" + TempSalesLine."Qty. to Invoice") > Abs(TempSalesLine."Return Qty. Received") then begin                                TempSalesLine.Validate(TempSalesLine."Qty. to Invoice", TempSalesLine."Return Qty. Received" - TempSalesLine."Quantity Invoiced");                                TempSalesLine."Qty. to Invoice (Base)" := TempSalesLine."Return Qty. Received (Base)" - TempSalesLine."Qty. Invoiced (Base)";                            end;                        TempSalesLine."Quantity Invoiced" += TempSalesLine."Qty. to Invoice";                        TempSalesLine."Qty. Invoiced (Base)" += TempSalesLine."Qty. to Invoice (Base)";                        ShouldCalcPrepmtAmounts := TempSalesLine."Qty. to Invoice" <> 0;                        OnPostUpdateOrderLineOnAfterCalcShouldCalcPrepmtAmounts(TempSalesLine, ShouldCalcPrepmtAmounts);                        if ShouldCalcPrepmtAmounts then begin                            TempSalesLine."Prepmt Amt Deducted" += TempSalesLine."Prepmt Amt to Deduct";                            TempSalesLine."Prepmt VAT Diff. Deducted" += TempSalesLine."Prepmt VAT Diff. to Deduct";                            DecrementPrepmtAmtInvLCY(SalesHeader, TempSalesLine, TempSalesLine."Prepmt. Amount Inv. (LCY)", TempSalesLine."Prepmt. VAT Amount Inv. (LCY)");                            TempSalesLine."Prepmt Amt to Deduct" := TempSalesLine."Prepmt. Amt. Inv." - TempSalesLine."Prepmt Amt Deducted";                            TempSalesLine."Prepmt VAT Diff. to Deduct" := 0;                        end;                    end;                    OnPostUpdateOrderLineOnAfterUpdateInvoicedValues(TempSalesLine, SalesHeader);                end;                OnPostItemTrackingForShipmentConditionOnBeforeUpdateBlanketOrderLine(TempSalesLine, SalesHeader);                UpdateBlanketOrderLine(TempSalesLine, SalesHeader.Ship, SalesHeader.Receive, SalesHeader.Invoice);                IsHandled := false;                OnPostUpdateOrderLineOnBeforeInitOutstanding(SalesHeader, TempSalesLine, IsHandled);                if not IsHandled then begin                    TempSalesLine.InitOutstanding();                    CheckATOLink(TempSalesLine);                    SetDefaultQtyBlank := SalesSetup."Default Quantity to Ship" = SalesSetup."Default Quantity to Ship"::Blank;                    OnPostUpdateOrderLineOnSetDefaultQtyBlank(SalesHeader, TempSalesLine, SalesSetup, SetDefaultQtyBlank);                    if WhseHandlingRequiredExternal(TempSalesLine) or SetDefaultQtyBlank then begin                        if TempSalesLine."Document Type" = TempSalesLine."Document Type"::"Return Order" then begin                            TempSalesLine."Return Qty. to Receive" := 0;                            TempSalesLine."Return Qty. to Receive (Base)" := 0;                        end else begin                            TempSalesLine."Qty. to Ship" := 0;                            TempSalesLine."Qty. to Ship (Base)" := 0;                        end;                        OnPostUpdateOrderLineBeforeInitQtyToInvoice(TempSalesLine, WhseShip, WhseReceive);                        TempSalesLine.InitQtyToInvoice();                    end else begin                        if TempSalesLine."Document Type" = TempSalesLine."Document Type"::"Return Order" then                            TempSalesLine.InitQtyToReceive()                        else                            TempSalesLine.InitQtyToShip2();                        OnPostUpdateOrderLineOnAfterInitQtyToReceiveOrShip(SalesHeader, TempSalesLine, WhseShip, WhseReceive);                    end;                    if (TempSalesLine."Purch. Order Line No." <> 0) and (TempSalesLine.Quantity = TempSalesLine."Quantity Invoiced") then                        UpdateAssocLines(TempSalesLine);                    TempSalesLine.SetDefaultQuantity();                    IsHandled := false;                    OnBeforePostUpdateOrderLineModifyTempLine(TempSalesLine, WhseShip, WhseReceive, SuppressCommit, IsHandled, SalesHeader);                    if not IsHandled then                        ModifyTempLine(TempSalesLine);                    OnAfterPostUpdateOrderLineModifyTempLine(TempSalesLine, WhseShip, WhseReceive, SuppressCommit, SalesHeader);                end;            until TempSalesLine.Next() = 0;        OnAfterPostUpdateOrderLine(TempSalesLine);    end;    local procedure PostUpdateInvoiceLine(var SalesHeader: Record "Sales Header")    var        SalesOrderLine: Record "Sales Line";        SalesShptLine: Record "Sales Shipment Line";        TempSalesLine: Record "Sales Line" temporary;        TempSalesOrderHeader: Record "Sales Header" temporary;        CRMSalesDocumentPostingMgt: Codeunit "CRM Sales Document Posting Mgt";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostUpdateInvoiceLine(TempSalesLineGlobal, IsHandled);        if IsHandled then            exit;        ResetTempLines(TempSalesLine);        TempSalesLine.SetFilter("Shipment No.", '<>%1', '');        TempSalesLine.SetFilter(Type, '<>%1', TempSalesLine.Type::" ");        if TempSalesLine.FindSet() then            repeat                SalesShptLine.Get(TempSalesLine."Shipment No.", TempSalesLine."Shipment Line No.");                SalesOrderLine.Get(                  SalesOrderLine."Document Type"::Order,                  SalesShptLine."Order No.", SalesShptLine."Order Line No.");                OnPostUpdateInvoiceLineOnAfterGetSalesOrderLine(TempSalesLine, SalesShptLine, SalesOrderLine);                if TempSalesLine.Type = TempSalesLine.Type::"Charge (Item)" then                    UpdateSalesOrderChargeAssgnt(TempSalesLine, SalesOrderLine);                IsHandled := false;                OnPostUpdateInvoiceLineOnBeforeCalcQuantityInvoiced(SalesOrderLine, TempSalesLine, IsHandled);                if not IsHandled then begin                    SalesOrderLine."Quantity Invoiced" += TempSalesLine."Qty. to Invoice";                    SalesOrderLine."Qty. Invoiced (Base)" += TempSalesLine."Qty. to Invoice (Base)";                end;                CheckSalesLineInvoiceMoreThanShipped(SalesOrderLine, TempSalesLine, SalesShptLine);                OnPostUpdateInvoiceLineOnBeforeInitQtyToInvoice(SalesOrderLine, TempSalesLine);                SalesOrderLine.InitQtyToInvoice();                if SalesOrderLine."Prepayment %" <> 0 then begin                    SalesOrderLine."Prepmt Amt Deducted" += TempSalesLine."Prepmt Amt to Deduct";                    SalesOrderLine."Prepmt VAT Diff. Deducted" += TempSalesLine."Prepmt VAT Diff. to Deduct";                    DecrementPrepmtAmtInvLCY(                      SalesHeader, TempSalesLine, SalesOrderLine."Prepmt. Amount Inv. (LCY)", SalesOrderLine."Prepmt. VAT Amount Inv. (LCY)");                    SalesOrderLine."Prepmt Amt to Deduct" :=                      SalesOrderLine."Prepmt. Amt. Inv." - SalesOrderLine."Prepmt Amt Deducted";                    SalesOrderLine."Prepmt VAT Diff. to Deduct" := 0;                end;                IsHandled := false;                OnPostUpdateInvoiceLineOnBeforeInitOutstanding(SalesOrderLine, IsHandled);                if not IsHandled then                    SalesOrderLine.InitOutstanding();                OnPostUpdateInvoiceLineOnBeforeModifySalesOrderLine(SalesOrderLine, TempSalesLine);                SalesOrderLine.Modify();                OnPostUpdateInvoiceLineOnAfterModifySalesOrderLine(SalesOrderLine, TempSalesLine);                if not TempSalesOrderHeader.Get(SalesOrderLine."Document Type", SalesOrderLine."Document No.") then begin                    TempSalesOrderHeader."Document Type" := SalesOrderLine."Document Type";                    TempSalesOrderHeader."No." := SalesOrderLine."Document No.";                    TempSalesOrderHeader.Insert();                end;                OnPostUpdateInvoiceLineOnAfterInsertSalesOrderHeader(SalesOrderLine, TempSalesLine);            until TempSalesLine.Next() = 0;        CRMSalesDocumentPostingMgt.CheckShippedOrders(TempSalesOrderHeader);        OnAfterPostUpdateInvoiceLine(TempSalesLine, SalesHeader, TempSalesOrderHeader);    end;    local procedure PostUpdateOrderNo(var SalesInvoiceHeader: Record "Sales Invoice Header")    var        SalesInvoiceLine: Record "Sales Invoice Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostUpdateOrderNo(SalesInvoiceHeader, IsHandled);        if IsHandled then            exit;        if SalesInvoiceHeader."No." = '' then            exit;        // Do not change 'Order No.' if already set        if SalesInvoiceHeader."Order No." <> '' then            exit;        // Get a line where 'Order No.' is set        SalesInvoiceLine.SetLoadFields("Order No.");        SalesInvoiceLine.SetRange("Document No.", SalesInvoiceHeader."No.");        SalesInvoiceLine.SetFilter(Type, '<>%1', SalesInvoiceLine.Type::" "); // Ignore comment lines        SalesInvoiceLine.SetFilter("Order No.", '<>%1', '');        if not SalesInvoiceLine.FindFirst() then            exit;        // If all the lines have the same 'Order No.' then set 'Order No.' field on the header        SalesInvoiceLine.SetFilter("Order No.", '<>%1', SalesInvoiceLine."Order No.");        if SalesInvoiceLine.IsEmpty() then begin            SalesInvoiceHeader.Validate("Order No.", SalesInvoiceLine."Order No.");            SalesInvoiceHeader.Modify(true);        end;    end;    local procedure CheckSalesLineInvoiceMoreThanShipped(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary; var SalesShptLine: Record "Sales Shipment Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckSalesLineInvoiceMoreThanShipped(SalesOrderLine, TempSalesLine, SalesShptLine, IsHandled);        if IsHandled then            exit;        if Abs(SalesOrderLine."Quantity Invoiced") > Abs(SalesOrderLine."Quantity Shipped") then            Error(InvoiceMoreThanShippedErr, SalesOrderLine."Document No.");    end;    /// <summary>    /// Updates return order lines after posting credit memos that reference return receipts.    /// Adjusts invoiced quantities and validates that invoiced quantity does not exceed received quantity.    /// </summary>    procedure PostUpdateReturnReceiptLine()    var        SalesOrderLine: Record "Sales Line";        ReturnRcptLine: Record "Return Receipt Line";        TempSalesLine: Record "Sales Line" temporary;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostUpdateReturnReceiptLine(TempSalesLineGlobal, IsHandled);        if IsHandled then            exit;        ResetTempLines(TempSalesLine);        TempSalesLine.SetFilter("Return Receipt No.", '<>%1', '');        TempSalesLine.SetFilter(Type, '<>%1', TempSalesLine.Type::" ");        if TempSalesLine.FindSet() then            repeat                ReturnRcptLine.Get(TempSalesLine."Return Receipt No.", TempSalesLine."Return Receipt Line No.");                SalesOrderLine.Get(                  SalesOrderLine."Document Type"::"Return Order",                  ReturnRcptLine."Return Order No.", ReturnRcptLine."Return Order Line No.");                OnPostUpdateReturnReceiptLineOnAfterGetSalesOrderLine(TempSalesLine, ReturnRcptLine, SalesOrderLine);                if TempSalesLine.Type = TempSalesLine.Type::"Charge (Item)" then                    UpdateSalesOrderChargeAssgnt(TempSalesLine, SalesOrderLine);                IsHandled := false;                OnPostUpdateReturnReceiptLineOnBeforeCalcQuantityInvoiced(SalesOrderLine, TempSalesLine, IsHandled);                if not IsHandled then begin                    SalesOrderLine."Quantity Invoiced" += TempSalesLine."Qty. to Invoice";                    SalesOrderLine."Qty. Invoiced (Base)" += TempSalesLine."Qty. to Invoice (Base)";                end;                if Abs(SalesOrderLine."Quantity Invoiced") > Abs(SalesOrderLine."Return Qty. Received") then                    Error(InvoiceMoreThanReceivedErr, SalesOrderLine."Document No.");                OnPostUpdateReturnReceiptLineOnBeforeInitQtyToInvoice(SalesOrderLine, TempSalesLine);                SalesOrderLine.InitQtyToInvoice();                IsHandled := false;                OnPostUpdateReturnReceiptLineOnBeforeInitOutstanding(SalesOrderLine, IsHandled);                if not IsHandled then                    SalesOrderLine.InitOutstanding();                OnPostUpdateReturnReceiptLineOnBeforeModifySalesOrderLine(SalesOrderLine, TempSalesLine);                SalesOrderLine.Modify();                OnPostUpdateReturnReceiptLineOnAfterModifySalesOrderLine(SalesOrderLine, TempSalesLine);            until TempSalesLine.Next() = 0;        OnAfterPostUpdateReturnReceiptLine(TempSalesLine);    end;    local procedure PostUpdateOrderNo(var SalesCrMemoHeader: Record "Sales Cr.Memo Header")    var        SalesCrMemoLine: Record "Sales Cr.Memo Line";        NoOfLines: Integer;        NoOfLinesWithOrderNo: Integer;        NoOfLinesWithParticularOrderNo: Integer;    begin        // Do not change 'Return Order No.' if already set        if SalesCrMemoHeader."Return Order No." <> '' then            exit;        SalesCrMemoLine.SetLoadFields("Order No.");        // Get number of lines. Ignore comment lines        SalesCrMemoLine.SetRange("Document No.", SalesCrMemoHeader."No.");        SalesCrMemoLine.SetFilter(Type, '<>%1', SalesCrMemoLine.Type::" "); // Ignore Comment lines        NoOfLines := SalesCrMemoLine.Count();        if NoOfLines = 0 then            exit;        // Get number of lines with filled in 'Order No.'        SalesCrMemoLine.SetFilter("Order No.", '<>%1', '');        NoOfLinesWithOrderNo := SalesCrMemoLine.Count();        if not SalesCrMemoLine.FindFirst() then            exit;        // Get number of lines with filled with a 'Order No.'        SalesCrMemoLine.SetRange("Order No.", SalesCrMemoLine."Order No.");        NoOfLinesWithParticularOrderNo := SalesCrMemoLine.Count();        SalesCrMemoLine.SetRange("Order No.");        if (NoOfLines = NoOfLinesWithOrderNo) and (NoOfLinesWithOrderNo = NoOfLinesWithParticularOrderNo) then begin            SalesCrMemoHeader.Validate("Return Order No.", SalesCrMemoLine."Order No.");            SalesCrMemoHeader.Modify(true);        end;    end;    local procedure CheckMandatoryHeaderFields(var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckMandatoryHeaderFields(SalesHeader, IsHandled);        if IsHandled then            exit;        SalesHeader.TestField("Document Type", ErrorInfo.Create());        SalesHeader.TestField("Sell-to Customer No.", ErrorInfo.Create());        SalesHeader.TestField("Bill-to Customer No.", ErrorInfo.Create());        SalesHeader.TestField("Posting Date", ErrorInfo.Create());        SalesHeader.TestField("Document Date", ErrorInfo.Create());        OnAfterCheckMandatoryFields(SalesHeader, SuppressCommit);    end;    local procedure ClearPostBuffers()    begin        Clear(WhsePostRcpt);        Clear(WhsePostShpt);        Clear(GenJnlPostLine);        Clear(ResJnlPostLine);        Clear(JobPostLine);        Clear(ItemJnlPostLine);        Clear(WhseJnlPostLine);    end;    /// <summary>    /// Sets the posting flags (Ship, Invoice, Receive) on the sales header based on the document type.    /// </summary>    /// <param name="SalesHeader">The sales header for which to set the posting flags.</param>    procedure SetPostingFlags(var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetPostingFlags(SalesHeader, IsHandled);        if IsHandled then            exit;        case SalesHeader."Document Type" of            SalesHeader."Document Type"::Order:                SalesHeader.Receive := false;            SalesHeader."Document Type"::Invoice:                begin                    SalesHeader.Ship := true;                    SalesHeader.Invoice := true;                    SalesHeader.Receive := false;                end;            SalesHeader."Document Type"::"Return Order":                SalesHeader.Ship := false;            SalesHeader."Document Type"::"Credit Memo":                begin                    SalesHeader.Ship := false;                    SalesHeader.Invoice := true;                    SalesHeader.Receive := true;                end;        end;        CheckPostingFlags(SalesHeader);    end;    local procedure CheckPostingFlags(var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckPostingFlags(SalesHeader, IsHandled);        if IsHandled then            exit;        if not (SalesHeader.Ship or SalesHeader.Invoice or SalesHeader.Receive) then            Error(ShipInvoiceReceiveErr);    end;    /// <summary>    /// Sets the Supress Commit flag.    /// </summary>    /// <param name="NewSuppressCommit">The new value of the Supress Commit flag.</param>    procedure SetSuppressCommit(NewSuppressCommit: Boolean)    begin        SuppressCommit := NewSuppressCommit;    end;    local procedure ClearAllVariables()    begin        ClearAll();        TempSalesLineGlobal.DeleteAll();        TempItemChargeAssgntSales.DeleteAll();        TempHandlingSpecification.DeleteAll();        TempATOTrackingSpecification.DeleteAll();        TempTrackingSpecification.DeleteAll();        TempTrackingSpecificationInv.DeleteAll();        TempWhseSplitSpecification.DeleteAll();        TempValueEntryRelation.DeleteAll();        TempICGenJnlLine.DeleteAll();        TempPrepmtDeductLCYSalesLine.DeleteAll();        TempSKU.DeleteAll();        TempDeferralHeader.DeleteAll();        TempDeferralLine.DeleteAll();        OrderArchived := false;    end;    local procedure CheckHeaderShippingAdvice(var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckHeaderShippingAdvice(SalesHeader, WhseShip, IsHandled);        if IsHandled then            exit;        if (SalesHeader."Shipping Advice" = SalesHeader."Shipping Advice"::Complete) and SalesHeader.Ship then            SalesHeader.CheckShippingAdvice();    end;    local procedure CheckHeaderPostingType(var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckHeaderPostingType(SalesHeader, IsHandled);        if IsHandled then            exit;        if not (SalesHeader.Ship or SalesHeader.Invoice or SalesHeader.Receive) then            Error(ErrorInfo.Create(DocumentErrorsMgt.GetNothingToPostErrorMsg(), true, SalesHeader));    end;    local procedure CheckAssosOrderLines(SalesHeader: Record "Sales Header")    var        SalesLine: Record "Sales Line";        PurchaseOrderLine: Record "Purchase Line";        PurchaseHeader: Record "Purchase Header";        TempPurchaseHeader: Record "Purchase Header" temporary;        TempPurchaseLine: Record "Purchase Line" temporary;        CheckDimensions: Codeunit "Check Dimensions";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckAssosOrderLines(SalesHeader, IsHandled);        if IsHandled then            exit;        SalesLine.Reset();        SalesLine.SetRange("Document Type", SalesHeader."Document Type");        SalesLine.SetRange("Document No.", SalesHeader."No.");        SalesLine.SetFilter("Purch. Order Line No.", '<>0');        SalesLine.SetFilter("Qty. to Ship", '<>0');        OnCheckAssosOrderLinesOnAfterSetFilters(SalesLine, SalesHeader);        if SalesLine.FindSet() then            repeat                PurchaseOrderLine.Get(                  PurchaseOrderLine."Document Type"::Order, SalesLine."Purchase Order No.", SalesLine."Purch. Order Line No.");                TempPurchaseLine := PurchaseOrderLine;                TempPurchaseLine.Insert();                TempPurchaseHeader."Document Type" := TempPurchaseHeader."Document Type"::Order;                TempPurchaseHeader."No." := SalesLine."Purchase Order No.";                if TempPurchaseHeader.Insert() then;            until SalesLine.Next() = 0;        if TempPurchaseHeader.FindSet() then            repeat                PurchaseHeader.Get(PurchaseHeader."Document Type"::Order, TempPurchaseHeader."No.");                TempPurchaseLine.SetRange("Document No.", TempPurchaseHeader."No.");                CheckDimensions.CheckPurchDim(PurchaseHeader, TempPurchaseLine);            until TempPurchaseHeader.Next() = 0;    end;    local procedure NeedUpdateGenProdPostingGroupOnItemChargeOnSalesLine(SalesLine: Record "Sales Line"): Boolean    var        NeedUpdate: Boolean;        IsHandled: Boolean;    begin        NeedUpdate := true;        IsHandled := false;        OnNeedUpdateGenProdPostingGroupOnItemChargeOnSalesLine(SalesLine, NeedUpdate, IsHandled);        if IsHandled then            exit(NeedUpdate);        if SalesLine.Type <> SalesLine.Type::"Charge (Item)" then            exit(false);        if SalesLine."No." = '' then            exit(false);        if ((SalesLine.Type = SalesLine.Type::"Charge (Item)") and (SalesLine."Gen. Prod. Posting Group" <> '')) then            exit(false);        exit(true);    end;    local procedure NeedUpdateGenProdPostingGroupOnItemChargeOnSalesShipmentLine(SalesShipmentLine: Record "Sales Shipment Line"): Boolean    var        NeedUpdate: Boolean;        IsHandled: Boolean;    begin        NeedUpdate := true;        IsHandled := false;        OnNeedUpdateGenProdPostingGroupOnItemChargeOnSalesShipmentLine(SalesShipmentLine, NeedUpdate, IsHandled);        if IsHandled then            exit(NeedUpdate);        if SalesShipmentLine.Type <> SalesShipmentLine.Type::"Charge (Item)" then            exit(false);        if SalesShipmentLine."No." = '' then            exit(false);        if ((SalesShipmentLine.Type = SalesShipmentLine.Type::"Charge (Item)") and (SalesShipmentLine."Gen. Prod. Posting Group" <> '')) then            exit(false);        exit(true);    end;    local procedure NeedUpdateGenProdPostingGroupOnItemChargeOnReturnRecepitLine(ReturnReceiptLine: Record "Return Receipt Line"): Boolean    var        NeedUpdate: Boolean;        IsHandled: Boolean;    begin        NeedUpdate := true;        IsHandled := false;        OnNeedUpdateGenProdPostingGroupOnItemChargeOnReturnReceiptLine(ReturnReceiptLine, NeedUpdate, IsHandled);        if IsHandled then            exit(NeedUpdate);        if ReturnReceiptLine.Type <> ReturnReceiptLine.Type::"Charge (Item)" then            exit(false);        if ReturnReceiptLine."No." = '' then            exit(false);        if ((ReturnReceiptLine.Type = ReturnReceiptLine.Type::"Charge (Item)") and (ReturnReceiptLine."Gen. Prod. Posting Group" <> '')) then            exit(false);        exit(true);    end;    local procedure CheckDefaultNoSeries(NoSeriesCode: Code[20])    var        NoSeries: Record "No. Series";    begin        if NoSeries.Get(NoSeriesCode) then            NoSeries.TestField("Default Nos.", true);    end;    local procedure CheckVATDate(var SalesHeader: Record "Sales Header")    begin        // ensure VAT Date is filled in        if SalesHeader."VAT Reporting Date" = 0D then begin            SalesHeader."VAT Reporting Date" := GLSetup.GetVATDate(SalesHeader."Posting Date", SalesHeader."Document Date");            SalesHeader.Modify();        end;    end;    local procedure ArchiveRelatedJob(SalesHeader: Record "Sales Header")    var        Job: Record Job;        SalesLine: Record "Sales Line";        JobArchiveManagement: Codeunit "Job Archive Management";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeArchiveRelatedJob(SalesHeader, IsHandled);        if IsHandled then            exit;        SalesLine.SetRange("Document Type", SalesHeader."Document Type");        SalesLine.SetRange("Document No.", SalesHeader."No.");        SalesLine.SetFilter("Job No.", '<>%1', '');        if not SalesLine.FindFirst() then            exit;        if Job.Get(SalesLine."Job No.") then            JobArchiveManagement.AutoArchiveJob(Job);    end;    local procedure IsInvoiceRoundingLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"): Boolean    var        CustomerPostingGroup: Record "Customer Posting Group";    begin        if SalesLine.Type <> SalesLine.Type::"G/L Account" then            exit(false);        CustomerPostingGroup.Get(SalesHeader."Customer Posting Group");        if SalesLine."No." = CustomerPostingGroup."Invoice Rounding Account" then            exit(true);        exit(false);    end;    local procedure UpdateSalesOrderLineIfExist(DocumentNo: Code[20])    var        SalesCreditMemoHeader: Record "Sales Cr.Memo Header";        CorrectPostedSalesInvoice: Codeunit "Correct Posted Sales Invoice";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateSalesOrderLineIfExist(DocumentNo, IsHandled);        if IsHandled then            exit;        SalesCreditMemoHeader.SetLoadFields("Return Order No.", "No.");        SalesCreditMemoHeader.SetRange("Return Order No.", DocumentNo);        if SalesCreditMemoHeader.FindFirst() then            CorrectPostedSalesInvoice.UpdateSalesOrderLineIfExist(SalesCreditMemoHeader."No.");    end;    /// <summary>    /// Raised before updating a sales order line from a posted sales return order.    /// </summary>    /// <param name="DocumentNo">The number of the sales return order.</param>    /// <param name="IsHandled">Set to true to skip the default sales order line update.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateSalesOrderLineIfExist(DocumentNo: Code[20]; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before posting sales lines.    /// </summary>    /// <param name="SalesLine">The sales line to be posted.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param>    /// <param name="TempWarehouseReceiptHeader">The temporary warehouse receipt header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostLines(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; PreviewMode: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary)    begin    end;    /// <summary>    /// Raised before posting a sales document.    /// </summary>    /// <param name="SalesHeader">The sales header to be posted.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="HideProgressWindow">Indicates whether to hide the progress window.</param>    /// <param name="IsHandled">Set to true to skip the default posting logic.</param>    /// <param name="CalledBy">Identifies the caller of the posting routine.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforePostSalesDoc(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; PreviewMode: Boolean; var HideProgressWindow: Boolean; var IsHandled: Boolean; var CalledBy: Integer)    begin    end;    /// <summary>    /// Raised before checking item tracking quantity on a sales line.    /// </summary>    /// <param name="SalesLine">The sales line to check.</param>    /// <param name="IsHandled">Set to true to skip the default quantity check.</param>    /// <param name="SalesHeader">The sales header of the document being posted.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckItemTrackingQuantity(SalesLine: Record "Sales Line"; var IsHandled: Boolean; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before checking the tracking specification for a sales document.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="TempItemSalesLine">The temporary sales line with item tracking.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckTrackingSpecification(SalesHeader: Record "Sales Header"; var TempItemSalesLine: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised before checking the certificate of supply status for a shipment.    /// </summary>    /// <param name="SalesShipmentHeader">The sales shipment header.</param>    /// <param name="SalesShipmentLine">The sales shipment line.</param>    /// <param name="IsHandled">Set to true to skip the default status check.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckCertificateOfSupplyStatus(SalesShipmentHeader: Record "Sales Shipment Header"; SalesShipmentLine: Record "Sales Shipment Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before committing the posted sales document.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="ModifyHeader">Indicates whether the header should be modified.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="TempSalesLineGlobal">The temporary sales lines being posted.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostCommitSalesDoc(var SalesHeader: Record "Sales Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; PreviewMode: Boolean; var ModifyHeader: Boolean; var CommitIsSuppressed: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised before determining end loop condition for received but not invoiced items.    /// </summary>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param>    /// <param name="ReturnReceiptLine">The return receipt line being processed.</param>    /// <param name="TempTrackingSpecification">The temporary tracking specification.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="EndLoop">Indicates whether to end the loop.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeIsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var ReturnReceiptLine: Record "Return Receipt Line"; var TempTrackingSpecification: Record "Tracking Specification"; SalesLine: Record "Sales Line"; var EndLoop: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised after calculating the prepayment VAT portion during prepayment amount adjustment.    /// </summary>    /// <param name="PrepmtVATPart">The calculated prepayment VAT portion.</param>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesLine">The sales line being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnAdjustPrepmtAmountLCYOnAfterCalcPrepmtVATPart(var PrepmtVATPart: Decimal; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised after calculating whether a new invoice is required.    /// </summary>    /// <param name="TempSalesLine">The temporary sales lines being processed.</param>    /// <param name="NewInvoice">Indicates whether a new invoice will be created.</param>    /// <param name="SalesHeader">The sales header being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCalcInvoice(var TempSalesLine: Record "Sales Line" temporary; var NewInvoice: Boolean; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after checking the sales document for posting readiness.    /// </summary>    /// <param name="SalesHeader">The sales header that was checked.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is required.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is required.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="ErrorMessageMgt">The error message management codeunit for handling errors.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckSalesDoc(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; WhseShip: Boolean; WhseReceive: Boolean; PreviewMode: Boolean; var ErrorMessageMgt: Codeunit "Error Message Management")    begin    end;    /// <summary>    /// Raised after checking and updating the sales header for posting.    /// </summary>    /// <param name="SalesHeader">The sales header that was checked and updated.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckAndUpdate(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; PreviewMode: Boolean)    begin    end;    /// <summary>    /// Raised after checking tracking and warehouse requirements for receiving.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="Receive">Indicates whether receiving is required.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="TempSalesLine">The temporary sales lines being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckTrackingAndWarehouseForReceive(var SalesHeader: Record "Sales Header"; var Receive: Boolean; CommitIsSuppressed: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; var TempSalesLine: record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised after checking tracking and warehouse requirements for shipping.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="Ship">Indicates whether shipping is required.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="TempSalesLine">The temporary sales lines being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckTrackingAndWarehouseForShip(var SalesHeader: Record "Sales Header"; var Ship: Boolean; CommitIsSuppressed: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised after creating a warehouse journal line.    /// </summary>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="TempWhseJnlLine">The temporary warehouse journal line that was created.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCreateWhseJnlLine(var SalesLine: Record "Sales Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary)    begin    end;    /// <summary>    /// Raised after copying sales lines to temporary lines.    /// </summary>    /// <param name="TempSalesLine">The temporary sales lines that were populated.</param>    /// <param name="SalesHeader">The sales header being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCopyToTempLines(var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after deleting documents after posting.    /// </summary>    /// <param name="SalesHeader">The sales header that was posted.</param>    /// <param name="SalesInvoiceHeader">The posted sales invoice header.</param>    /// <param name="SalesCrMemoHeader">The posted sales credit memo header.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterDeleteAfterPosting(SalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised after retrieving the general ledger setup.    /// </summary>    /// <param name="GLSetup">The general ledger setup that was retrieved.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterGetGLSetup(var GLSetup: Record "General Ledger Setup")    begin    end;    /// <summary>    /// Raised after retrieving sales lines for posting.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    /// <param name="NewSalesLine">The new sales line record.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterGetSalesLines(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: record "Sales Line"; var NewSalesLine: record "Sales Line");    begin    end;    /// <summary>    /// Raised after retrieving line data from the sales order.    /// </summary>    /// <param name="SalesLine">The sales line being populated.</param>    /// <param name="SalesOrderLine">The source sales order line.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterGetLineDataFromOrder(var SalesLine: Record "Sales Line"; SalesOrderLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised after retrieving the sales and receivables setup.    /// </summary>    /// <param name="SalesSetup">The sales and receivables setup that was retrieved.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterGetSalesSetup(var SalesSetup: Record "Sales & Receivables Setup")    begin    end;    /// <summary>    /// Raised before retrieving sales lines for posting.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="NewSalesLine">The sales line record to be populated.</param>    /// <param name="QtyType">The quantity type to retrieve.</param>    /// <param name="IncludePrepayments">Indicates whether to include prepayments.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetSalesLines(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; QtyType: Option; IncludePrepayments: Boolean)    begin    end;    /// <summary>    /// Raised before retrieving sales lines into temporary records.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="NewSalesLine">The new sales line record.</param>    /// <param name="OldSalesLine">The original sales line record.</param>    /// <param name="QtyType">The quantity type to retrieve.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetSalesLinesTemp(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; QtyType: Option)    begin    end;    /// <summary>    /// Raised after incrementing the total amount with a sales line.    /// </summary>    /// <param name="TotalSalesLine">The total sales line being accumulated.</param>    /// <param name="SalesLine">The sales line being added to the total.</param>    /// <param name="SalesHeader">The sales header being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterIncrAmount(var TotalSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after initializing an associated item journal line for drop shipment.    /// </summary>    /// <param name="ItemJournalLine">The item journal line that was initialized.</param>    /// <param name="PurchaseHeader">The associated purchase header.</param>    /// <param name="PurchaseLine">The associated purchase line.</param>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="QtyToBeShipped">The quantity to be shipped.</param>    /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInitAssocItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal)    begin    end;    /// <summary>    /// Raised after calculating the invoice rounding amount.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesLine">The sales line for invoice rounding.</param>    /// <param name="TotalSalesLine">The total sales line amounts.</param>    /// <param name="UseTempData">Indicates whether to use temporary data.</param>    /// <param name="InvoiceRoundingAmount">The calculated invoice rounding amount.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="Currency">The currency used for rounding.</param>    /// <param name="BiggestLineNo">The biggest line number in the document.</param>    /// <param name="LastLineRetrieved">Indicates whether the last line was retrieved.</param>    /// <param name="RoundingLineInserted">Indicates whether a rounding line was inserted.</param>    /// <param name="RoundingLineNo">The line number of the rounding line.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInvoiceRoundingAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TotalSalesLine: Record "Sales Line"; UseTempData: Boolean; InvoiceRoundingAmount: Decimal; CommitIsSuppressed: Boolean; Currency: Record Currency; var BiggestLineNo: Integer; var LastLineRetrieved: Boolean; var RoundingLineInserted: Boolean; var RoundingLineNo: Integer)    begin    end;    /// <summary>    /// Raised after inserting a drop shipment purchase receipt header.    /// </summary>    /// <param name="PurchRcptHeader">The purchase receipt header that was inserted.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInsertDropOrderPurchRcptHeader(var PurchRcptHeader: Record "Purch. Rcpt. Header")    begin    end;    /// <summary>    /// Raised after inserting a sales credit memo header.    /// </summary>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header that was inserted.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInsertCrMemoHeader(var SalesHeader: Record "Sales Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header")    begin    end;    /// <summary>    /// Raised after inserting a sales invoice header.    /// </summary>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="SalesInvHeader">The sales invoice header that was inserted.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInsertInvoiceHeader(var SalesHeader: Record "Sales Header"; var SalesInvHeader: Record "Sales Invoice Header")    begin    end;    /// <summary>    /// Raised after inserting the prepayment VAT base to deduct.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="PrepmtLineNo">The prepayment line number.</param>    /// <param name="TotalPrepmtAmtToDeduct">The total prepayment amount to deduct.</param>    /// <param name="TempPrepmtDeductLCYSalesLine">The temporary prepayment deduction line in LCY.</param>    /// <param name="PrepmtVATBaseToDeduct">The prepayment VAT base amount to deduct.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInsertedPrepmtVATBaseToDeduct(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; PrepmtLineNo: Integer; TotalPrepmtAmtToDeduct: Decimal; var TempPrepmtDeductLCYSalesLine: Record "Sales Line" temporary; var PrepmtVATBaseToDeduct: Decimal)    begin    end;    /// <summary>    /// Raised after inserting all posted headers (shipment, invoice, credit memo, receipt).    /// </summary>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="SalesShipmentHeader">The posted sales shipment header.</param>    /// <param name="SalesInvoiceHeader">The posted sales invoice header.</param>    /// <param name="SalesCrMemoHdr">The posted sales credit memo header.</param>    /// <param name="ReceiptHeader">The posted return receipt header.</param>    /// <param name="GenJournalDocumentType">The general journal document type.</param>    /// <param name="GenJnlLineDocNo">The general journal line document number.</param>    /// <param name="GenJnlLineExtDocNo">The general journal line external document number.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInsertPostedHeaders(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHdr: Record "Sales Cr.Memo Header"; var ReceiptHeader: Record "Return Receipt Header"; var GenJournalDocumentType: Enum "Gen. Journal Document Type"; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35])    begin    end;    /// <summary>    /// Raised after inserting a sales shipment header.    /// </summary>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="SalesShipmentHeader">The sales shipment header that was inserted.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInsertShipmentHeader(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header")    begin    end;    /// <summary>    /// Raised after inserting a sales shipment line.    /// </summary>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="SalesShptLine">The sales shipment line that was inserted.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="xSalesLine">The original sales line before modification.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInsertShipmentLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesShptLine: record "Sales Shipment Line"; PreviewMode: Boolean; xSalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised after inserting a return receipt line for warehouse posting.    /// </summary>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="xSalesLine">The original sales line before modification.</param>    /// <param name="ReturnReceiptLine">The return receipt line that was inserted.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInsertReturnReceiptLineWhsePost(var SalesLine: Record "Sales Line"; xSalesLine: Record "Sales Line"; var ReturnReceiptLine: Record "Return Receipt Line")    begin    end;    /// <summary>    /// Raised after posting a drop shipment order.    /// </summary>    /// <param name="TempDropShptPostBuffer">The temporary drop shipment posting buffer.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostDropOrderShipment(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    /// <summary>    /// Raised after posting a sales document.    /// </summary>    /// <param name="SalesHeader">The sales header that was posted.</param>    /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param>    /// <param name="SalesShptHdrNo">The posted sales shipment header number.</param>    /// <param name="RetRcpHdrNo">The posted return receipt header number.</param>    /// <param name="SalesInvHdrNo">The posted sales invoice header number.</param>    /// <param name="SalesCrMemoHdrNo">The posted sales credit memo header number.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="InvtPickPutaway">Indicates whether inventory pick/put-away is involved.</param>    /// <param name="CustLedgerEntry">The customer ledger entry that was created.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment was processed.</param>    /// <param name="WhseReceiv">Indicates whether warehouse receipt was processed.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostSalesDoc(var SalesHeader: Record "Sales Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; SalesShptHdrNo: Code[20]; RetRcpHdrNo: Code[20]; SalesInvHdrNo: Code[20]; SalesCrMemoHdrNo: Code[20]; CommitIsSuppressed: Boolean; InvtPickPutaway: Boolean; var CustLedgerEntry: Record "Cust. Ledger Entry"; WhseShip: Boolean; WhseReceiv: Boolean; PreviewMode: Boolean)    begin    end;    /// <summary>    /// Raised after updating the order line after posting.    /// </summary>    /// <param name="TempSalesLine">The temporary sales line that was updated.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostUpdateOrderLine(var TempSalesLine: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised after posting a sales document with drop shipment.    /// </summary>    /// <param name="PurchRcptNo">The purchase receipt number for the drop shipment.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostSalesDocDropShipment(PurchRcptNo: Code[20]; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised after posting an item journal line for a sales line.    /// </summary>    /// <param name="ItemJournalLine">The item journal line that was posted.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param>    /// <param name="WhseJnlPostLine">The warehouse journal register line codeunit instance.</param>    /// <param name="OriginalItemJnlLine">The original item journal line before posting.</param>    /// <param name="ItemShptEntryNo">The item shipment entry number.</param>    /// <param name="IsATO">Indicates whether this is an assemble-to-order transaction.</param>    /// <param name="TempHandlingSpecification">The temporary handling tracking specification.</param>    /// <param name="TempATOTrackingSpecification">The temporary ATO tracking specification.</param>    /// <param name="TempWarehouseJournalLine">The temporary warehouse journal line.</param>    /// <param name="ShouldPostItemJnlLine">Indicates whether the item journal line should be posted.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseRcptHeader">The warehouse receipt header.</param>    [IntegrationEvent(true, false)]    local procedure OnAfterPostItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var WhseJnlPostLine: Codeunit "Whse. Jnl.-Register Line"; OriginalItemJnlLine: Record "Item Journal Line"; var ItemShptEntryNo: Integer; IsATO: Boolean; var TempHandlingSpecification: Record "Tracking Specification"; var TempATOTrackingSpecification: Record "Tracking Specification"; TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary; ShouldPostItemJnlLine: Boolean; WhseShip: Boolean; WhseRcptHeader: Record "Warehouse Receipt Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header")    begin    end;    /// <summary>    /// Raised after posting all sales lines.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesShipmentHeader">The sales shipment header.</param>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    /// <param name="ReturnReceiptHeader">The return receipt header.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment was processed.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt was processed.</param>    /// <param name="SalesLinesProcessed">Indicates whether sales lines were processed.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="EverythingInvoiced">Indicates whether all lines were invoiced.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostSalesLines(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptHeader: Record "Return Receipt Header"; WhseShip: Boolean; WhseReceive: Boolean; var SalesLinesProcessed: Boolean; CommitIsSuppressed: Boolean; EverythingInvoiced: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised after posting a sales line.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line that was posted.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="SalesInvLine">The sales invoice line that was created.</param>    /// <param name="SalesCrMemoLine">The sales credit memo line that was created.</param>    /// <param name="xSalesLine">The original sales line before posting.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostSalesLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; var SalesInvLine: Record "Sales Invoice Line"; var SalesCrMemoLine: Record "Sales Cr.Memo Line"; var xSalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised after updating the invoice line during post update processing.    /// </summary>    /// <param name="TempSalesLine">The temporary sales line that was updated.</param>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="TempSalesOrderHeader">The temporary sales order header.</param>    [IntegrationEvent(true, false)]    local procedure OnAfterPostUpdateInvoiceLine(var TempSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var TempSalesOrderHeader: Record "Sales Header" temporary)    begin    end;    /// <summary>    /// Raised after updating the return receipt line during post update processing.    /// </summary>    /// <param name="TempSalesLine">The temporary sales line that was updated.</param>    [IntegrationEvent(true, false)]    local procedure OnAfterPostUpdateReturnReceiptLine(var TempSalesLine: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised after updating item charge assignments.    /// </summary>    /// <param name="SalesHeader">The sales header that was updated.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateItemChargeAssgnt(var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after updating posting numbers.    /// </summary>    /// <param name="SalesHeader">The sales header that was updated.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdatePostingNos(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised after updating the return receipt number.    /// </summary>    /// <param name="SalesHeader">The sales header that was updated.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateReturnReceiptNo(var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after updating the shipping number.    /// </summary>    /// <param name="SalesHeader">The sales header that was updated.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="ModifyHeader">Indicates whether the header should be modified.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateShippingNo(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean; var ModifyHeader: Boolean)    begin    end;    /// <summary>    /// Raised after updating won opportunities.    /// </summary>    /// <param name="SalesHeader">The sales header that was posted.</param>    /// <param name="SalesInvoiceHeader">The posted sales invoice header.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateWonOpportunities(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header")    begin    end;    /// <summary>    /// Raised after checking mandatory fields.    /// </summary>    /// <param name="SalesHeader">The sales header that was checked.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckMandatoryFields(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised after inserting the sales invoice header.    /// </summary>    /// <param name="SalesInvHeader">The sales invoice header that was inserted.</param>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSalesInvHeaderInsert(var SalesInvHeader: Record "Sales Invoice Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header"; PreviewMode: Boolean)    begin    end;    /// <summary>    /// Raised after inserting a sales invoice line.    /// </summary>    /// <param name="SalesInvLine">The sales invoice line that was inserted.</param>    /// <param name="SalesInvHeader">The sales invoice header.</param>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="ItemLedgShptEntryNo">The item ledger shipment entry number.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="TempItemChargeAssgntSales">The temporary item charge assignment records.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSalesInvLineInsert(var SalesInvLine: Record "Sales Invoice Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesLine: Record "Sales Line"; ItemLedgShptEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; var SalesHeader: Record "Sales Header"; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; PreviewMode: Boolean)    begin    end;    /// <summary>    /// Raised after inserting the sales credit memo header.    /// </summary>    /// <param name="SalesCrMemoHeader">The sales credit memo header that was inserted.</param>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSalesCrMemoHeaderInsert(var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header")    begin    end;    /// <summary>    /// Raised after inserting a sales credit memo line.    /// </summary>    /// <param name="SalesCrMemoLine">The sales credit memo line that was inserted.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="TempItemChargeAssgntSales">The temporary item charge assignment records.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSalesCrMemoLineInsert(var SalesCrMemoLine: Record "Sales Cr.Memo Line"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; CommitIsSuppressed: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary)    begin    end;    /// <summary>    /// Raised after inserting the sales shipment header.    /// </summary>    /// <param name="SalesShipmentHeader">The sales shipment header that was inserted.</param>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="SuppressCommit">Indicates whether database commits are suppressed.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSalesShptHeaderInsert(var SalesShipmentHeader: Record "Sales Shipment Header"; SalesHeader: Record "Sales Header"; SuppressCommit: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header"; PreviewMode: Boolean)    begin    end;    /// <summary>    /// Raised after inserting a sales shipment line.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line that was inserted.</param>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="ItemShptLedEntryNo">The item shipment ledger entry number.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="SalesShptHeader">The sales shipment header.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSalesShptLineInsert(var SalesShipmentLine: Record "Sales Shipment Line"; SalesLine: Record "Sales Line"; ItemShptLedEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; SalesInvoiceHeader: Record "Sales Invoice Header"; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; SalesShptHeader: Record "Sales Shipment Header"; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after inserting the purchase receipt header for a drop shipment.    /// </summary>    /// <param name="PurchRcptHeader">The purchase receipt header that was inserted.</param>    /// <param name="PurchaseHeader">The source purchase header.</param>    /// <param name="SalesHeader">The related sales header.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPurchRcptHeaderInsert(var PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchaseHeader: Record "Purchase Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised after inserting a purchase receipt line for a drop shipment.    /// </summary>    /// <param name="PurchRcptLine">The purchase receipt line that was inserted.</param>    /// <param name="PurchRcptHeader">The purchase receipt header.</param>    /// <param name="PurchOrderLine">The source purchase order line.</param>    /// <param name="DropShptPostBuffer">The drop shipment posting buffer.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPurchRcptLineInsert(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchOrderLine: Record "Purchase Line"; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer"; CommitIsSuppressed: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised after inserting the return receipt header.    /// </summary>    /// <param name="ReturnReceiptHeader">The return receipt header that was inserted.</param>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="SuppressCommit">Indicates whether database commits are suppressed.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterReturnRcptHeaderInsert(var ReturnReceiptHeader: Record "Return Receipt Header"; SalesHeader: Record "Sales Header"; SuppressCommit: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header")    begin    end;    /// <summary>    /// Raised after inserting a return receipt line.    /// </summary>    /// <param name="ReturnRcptLine">The return receipt line that was inserted.</param>    /// <param name="ReturnRcptHeader">The return receipt header.</param>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="ItemShptLedEntryNo">The item shipment ledger entry number.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterReturnRcptLineInsert(var ReturnRcptLine: Record "Return Receipt Line"; ReturnRcptHeader: Record "Return Receipt Header"; SalesLine: Record "Sales Line"; ItemShptLedEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after finalizing the posting process.    /// </summary>    /// <param name="SalesHeader">The sales header that was posted.</param>    /// <param name="SalesShipmentHeader">The sales shipment header that was created.</param>    /// <param name="SalesInvoiceHeader">The sales invoice header that was created.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header that was created.</param>    /// <param name="ReturnReceiptHeader">The return receipt header that was created.</param>    /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterFinalizePosting(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptHeader: Record "Return Receipt Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; CommitIsSuppressed: Boolean; PreviewMode: Boolean)    begin    end;    /// <summary>    /// Raised after finalizing posting but before the database commit.    /// </summary>    /// <param name="SalesHeader">The sales header that was posted.</param>    /// <param name="SalesShipmentHeader">The sales shipment header that was created.</param>    /// <param name="SalesInvoiceHeader">The sales invoice header that was created.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header that was created.</param>    /// <param name="ReturnReceiptHeader">The return receipt header that was created.</param>    /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment was processed.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt was processed.</param>    /// <param name="EverythingInvoiced">Indicates whether all lines were invoiced.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterFinalizePostingOnBeforeCommit(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptHeader: Record "Return Receipt Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var CommitIsSuppressed: Boolean; var PreviewMode: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var EverythingInvoiced: Boolean)    begin    end;    /// <summary>    /// Raised after finding lines that have not been shipped.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="TempSalesLine">The temporary sales lines that have not been shipped.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterFindNotShippedLines(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised after resetting temporary sales lines.    /// </summary>    /// <param name="TempSalesLineLocal">The temporary sales lines that were reset.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterResetTempLines(var TempSalesLineLocal: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised after restoring the sales header from a copy.    /// </summary>    /// <param name="SalesHeader">The sales header that was restored.</param>    /// <param name="SalesHeaderCopy">The copy of the sales header used for restoration.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterRestoreSalesHeader(var SalesHeader: Record "Sales Header"; SalesHeaderCopy: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after updating the sales header after posting.    /// </summary>    /// <param name="SalesHeader">The sales header that was updated.</param>    /// <param name="TempSalesLine">The temporary sales lines.</param>    [IntegrationEvent(true, false)]    local procedure OnAfterUpdateAfterPosting(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised after updating the last posting numbers.    /// </summary>    /// <param name="SalesHeader">The sales header that was updated.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateLastPostingNos(var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after updating the sales header with posting information.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry that was created.</param>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    /// <param name="GenJnlLineDocType">The general journal line document type.</param>    /// <param name="GenJnlLineDocNo">The general journal line document number.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="SalesHeader">The sales header that was updated.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateSalesHeader(var CustLedgerEntry: Record "Cust. Ledger Entry"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; GenJnlLineDocType: Integer; GenJnlLineDocNo: Code[20]; PreviewMode: Boolean; var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after updating the sales line before posting.    /// </summary>    /// <param name="SalesLine">The sales line that was updated.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateSalesLineBeforePost(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised after checking if warehouse lines exist.    /// </summary>    /// <param name="WhseValidateSourceLine">The warehouse validate source line codeunit instance.</param>    /// <param name="SalesLine">The sales line being checked.</param>    /// <param name="ShowError">Indicates whether to show an error.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterWhseLinesExist(var WhseValidateSourceLine: Codeunit "Whse. Validate Source Line"; SalesLine: Record "Sales Line"; var ShowError: Boolean)    begin    end;    /// <summary>    /// Raised before archiving the unposted order.    /// </summary>    /// <param name="SalesHeader">The sales header to be archived.</param>    /// <param name="IsHandled">Set to true to skip the default archiving logic.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="OrderArchived">Indicates whether the order was archived.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeArchiveUnpostedOrder(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; PreviewMode: Boolean; var OrderArchived: Boolean)    begin    end;    /// <summary>    /// Raised before confirming the download of a shipment.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="Result">The result of the confirmation.</param>    /// <param name="IsHandled">Set to true to skip the default confirmation logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeConfirmDownloadShipment(var SalesHeader: Record "Sales Header"; var Result: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before creating the posted warehouse receipt header.    /// </summary>    /// <param name="PostedWhseReceiptHeader">The posted warehouse receipt header to be created.</param>    /// <param name="WarehouseReceiptHeader">The source warehouse receipt header.</param>    /// <param name="SalesHeader">The related sales header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCreatePostedWhseRcptHeader(var PostedWhseReceiptHeader: Record "Posted Whse. Receipt Header"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before creating prepayment lines.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="TempPrepmtSalesLine">The temporary prepayment sales lines to be created.</param>    /// <param name="CompleteFunctionality">Indicates whether complete functionality is enabled.</param>    /// <param name="IsHandled">Set to true to skip the default prepayment line creation.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforeCreatePrepaymentLines(var SalesHeader: Record "Sales Header"; var TempPrepmtSalesLine: Record "Sales Line" temporary; CompleteFunctionality: Boolean; var IsHandled: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised before modifying the blanket order sales line.    /// </summary>    /// <param name="BlanketOrderSalesLine">The blanket order sales line to be modified.</param>    /// <param name="SalesLine">The source sales line.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeBlanketOrderSalesLineModify(var BlanketOrderSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised before creating the posted warehouse shipment header.    /// </summary>    /// <param name="PostedWhseShipmentHeader">The posted warehouse shipment header to be created.</param>    /// <param name="WarehouseShipmentHeader">The source warehouse shipment header.</param>    /// <param name="SalesHeader">The related sales header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCreatePostedWhseShptHeader(var PostedWhseShipmentHeader: Record "Posted Whse. Shipment Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before creating a warehouse journal line.    /// </summary>    /// <param name="ItemJnlLine">The item journal line being processed.</param>    /// <param name="IsHandled">Set to true to skip the default warehouse journal line creation.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateWhseJnlLine(ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before finalizing the posting process.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    /// <param name="EverythingInvoiced">Indicates whether all lines were invoiced.</param>    /// <param name="SuppressCommit">Indicates whether database commits are suppressed.</param>    /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforeFinalizePosting(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var EverythingInvoiced: Boolean; SuppressCommit: Boolean; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")    begin    end;    /// <summary>    /// Raised before initializing an associated item journal line for drop shipment.    /// </summary>    /// <param name="ItemJournalLine">The item journal line to be initialized.</param>    /// <param name="PurchaseHeader">The associated purchase header.</param>    /// <param name="PurchaseLine">The associated purchase line.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInitAssocItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised before inserting an intercompany general journal line.    /// </summary>    /// <param name="ICGenJournalLine">The intercompany general journal line to be inserted.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertICGenJnlLine(var ICGenJournalLine: Record "Gen. Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised before inserting posted document headers.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="TempWarehouseShipmentHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWarehouseReceiptHeader">The temporary warehouse receipt header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertPostedHeaders(var SalesHeader: Record "Sales Header"; var TempWarehouseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary)    begin    end;    /// <summary>    /// Raised before inserting the return receipt header.    /// </summary>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="ReturnReceiptHeader">The return receipt header to be inserted.</param>    /// <param name="Handled">Set to true to skip the default insertion logic.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertReturnReceiptHeader(SalesHeader: Record "Sales Header"; var ReturnReceiptHeader: Record "Return Receipt Header"; var Handled: Boolean; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised before inserting a return receipt line during warehouse posting.    /// </summary>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="ReturnRcptHeader">The return receipt header.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    /// <param name="ReturnRcptLine">The return receipt line to be inserted.</param>    /// <param name="xSalesLine">The original sales line before modification.</param>    /// <param name="PostedWhseRcptHeader">The posted warehouse receipt header.</param>    /// <param name="WhseRcptHeader">The warehouse receipt header.</param>    /// <param name="CostBaseAmount">The cost base amount.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertReturnReceiptLineWhsePost(SalesLine: Record "Sales Line"; ReturnRcptHeader: Record "Return Receipt Header"; WhseShip: Boolean; WhseReceive: Boolean; TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; var IsHandled: Boolean; var ReturnRcptLine: Record "Return Receipt Line"; var xSalesLine: Record "Sales Line"; PostedWhseRcptHeader: Record "Posted Whse. Receipt Header"; WhseRcptHeader: Record "Warehouse Receipt Header"; var CostBaseAmount: Decimal)    begin    end;    /// <summary>    /// Raised before inserting the return entry relation.    /// </summary>    /// <param name="ReturnRcptLine">The return receipt line.</param>    /// <param name="EntryNo">The entry number.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertReturnEntryRelation(var ReturnRcptLine: Record "Return Receipt Line"; var EntryNo: Integer; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before inserting the shipment entry relation.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesShptLine">The sales shipment line.</param>    /// <param name="ItemShptEntryNo">The item shipment entry number.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertShptEntryRelation(SalesHeader: Record "Sales Header"; var SalesShptLine: Record "Sales Shipment Line"; var ItemShptEntryNo: Integer; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before inserting the sales invoice header.    /// </summary>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="SalesInvHeader">The sales invoice header to be inserted.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertInvoiceHeader(SalesHeader: Record "Sales Header"; var SalesInvHeader: Record "Sales Invoice Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before calculating the invoice rounding amount.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="TotalAmountIncludingVAT">The total amount including VAT.</param>    /// <param name="UseTempData">Indicates whether temporary data is being used.</param>    /// <param name="InvoiceRoundingAmount">The invoice rounding amount.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="TotalSalesLine">The total sales line record.</param>    /// <param name="Currency">The currency record.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInvoiceRoundingAmount(SalesHeader: Record "Sales Header"; TotalAmountIncludingVAT: Decimal; UseTempData: Boolean; var InvoiceRoundingAmount: Decimal; CommitIsSuppressed: Boolean; var TotalSalesLine: Record "Sales Line"; var Currency: Record Currency)    begin    end;    /// <summary>    /// Raised before determining if the loop should end for shipped but not invoiced items.    /// </summary>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param>    /// <param name="HasATOShippedNotInvoiced">Indicates whether there are assemble-to-order items shipped but not invoiced.</param>    /// <param name="SalesShptLine">The sales shipment line.</param>    /// <param name="InvoicingTrackingSpecification">The invoicing tracking specification.</param>    /// <param name="ItemLedgEntryNotInvoiced">The item ledger entry not invoiced.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="Result">The result indicating whether to end the loop.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeIsEndLoopForShippedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var HasATOShippedNotInvoiced: Boolean; var SalesShptLine: Record "Sales Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; var ItemLedgEntryNotInvoiced: Record "Item Ledger Entry"; SalesLine: Record "Sales Line"; var Result: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before posting the item journal line.    /// </summary>    /// <param name="ItemJournalLine">The item journal line to be posted.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default posting logic.</param>    /// <param name="TempItemChargeAssgntSales">The temporary item charge assignment records.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeItemJnlPostLine(var ItemJournalLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary)    begin    end;    /// <summary>    /// Raised before handling the archiving of an unposted order.    /// </summary>    /// <param name="SalesHeader">The sales header to be archived.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="IsHandled">Set to true to skip the default archiving logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeHandleArchiveUnpostedOrder(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before locking database tables.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default table locking logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeLockTables(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean; CommitIsSuppressed: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before making inventory adjustment during the Run procedure.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesInvHeader">The sales invoice header.</param>    /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param>    /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="SkipInventoryAdjustment">Indicates whether to skip the inventory adjustment.</param>    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforeMakeInventoryAdjustment(var SalesHeader: Record "Sales Header"; SalesInvHeader: Record "Sales Invoice Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; PreviewMode: Boolean; var SkipInventoryAdjustment: Boolean)    begin    end;    /// <summary>    /// Raised before posting the intercompany general journal during the Run procedure.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param>    /// <param name="SrcCode">The source code.</param>    /// <param name="GenJnlLineDocType">The general journal line document type.</param>    /// <param name="GenJnlLineDocNo">The general journal line document number.</param>    /// <param name="ReturnReceiptHeader">The return receipt header.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforePostICGenJnl(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var SrcCode: Code[10]; var GenJnlLineDocType: Enum "Gen. Journal Document Type"; GenJnlLineDocNo: Code[20]; var ReturnReceiptHeader: Record "Return Receipt Header"; var PreviewMode: Boolean)    begin    end;    /// <summary>    /// Raised before preparing to check the document.    /// </summary>    /// <param name="SalesHeader">The sales header to be checked.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePrepareCheckDocument(var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before processing the associated item journal line for drop shipment.    /// </summary>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="IsHandled">Set to true to skip the default processing logic.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="TempDropShptPostBuffer">The temporary drop shipment posting buffer.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeProcessAssocItemJnlLine(var SalesLine: Record "Sales Line"; var IsHandled: Boolean; var SalesHeader: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    /// <summary>    /// Raised before deleting all sales lines.    /// </summary>    /// <param name="SalesLine">The sales line record set to be deleted.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSalesLineDeleteAll(var SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before inserting the sales shipment header.    /// </summary>    /// <param name="SalesShptHeader">The sales shipment header to be inserted.</param>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="InvtPickPutaway">Indicates whether inventory pick/put-away is involved.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSalesShptHeaderInsert(var SalesShptHeader: Record "Sales Shipment Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; WhseShip: Boolean; InvtPickPutaway: Boolean)    begin    end;    /// <summary>    /// Raised before inserting a sales shipment line.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line to be inserted.</param>    /// <param name="SalesShptHeader">The sales shipment header.</param>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="PostedWhseShipmentLine">The posted warehouse shipment line.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="ItemLedgShptEntryNo">The item ledger shipment entry number.</param>    /// <param name="xSalesLine">The original sales line before modification.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSalesShptLineInsert(var SalesShptLine: Record "Sales Shipment Line"; SalesShptHeader: Record "Sales Shipment Header"; SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; PostedWhseShipmentLine: Record "Posted Whse. Shipment Line"; SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; ItemLedgShptEntryNo: Integer; xSalesLine: record "Sales Line"; var TempSalesLineGlobal: record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before inserting the sales invoice header.    /// </summary>    /// <param name="SalesInvHeader">The sales invoice header to be inserted.</param>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseShptHeader">The warehouse shipment header.</param>    /// <param name="InvtPickPutaway">Indicates whether inventory pick/put-away is involved.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSalesInvHeaderInsert(var SalesInvHeader: Record "Sales Invoice Header"; var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; WhseShip: Boolean; WhseShptHeader: Record "Warehouse Shipment Header"; InvtPickPutaway: Boolean)    begin    end;    /// <summary>    /// Raised before inserting a sales invoice line.    /// </summary>    /// <param name="SalesInvLine">The sales invoice line to be inserted.</param>    /// <param name="SalesInvHeader">The sales invoice header.</param>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    /// <param name="PostingSalesLine">The posting sales line.</param>    /// <param name="SalesShipmentHeader">The sales shipment header.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="ReturnReceiptHeader">The return receipt header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSalesInvLineInsert(var SalesInvLine: Record "Sales Invoice Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; PostingSalesLine: Record "Sales Line"; SalesShipmentHeader: Record "Sales Shipment Header"; SalesHeader: Record "Sales Header"; var ReturnReceiptHeader: Record "Return Receipt Header")    begin    end;    /// <summary>    /// Raised before inserting the sales credit memo header.    /// </summary>    /// <param name="SalesCrMemoHeader">The sales credit memo header to be inserted.</param>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    /// <param name="SalesInvHeader">The sales invoice header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSalesCrMemoHeaderInsert(var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; var SalesInvHeader: Record "Sales Invoice Header")    begin    end;    /// <summary>    /// Raised before inserting a sales credit memo line.    /// </summary>    /// <param name="SalesCrMemoLine">The sales credit memo line to be inserted.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesShptHeader">The sales shipment header.</param>    /// <param name="ReturnRcptHeader">The return receipt header.</param>    /// <param name="PostingSalesLine">The posting sales line.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSalesCrMemoLineInsert(var SalesCrMemoLine: Record "Sales Cr.Memo Line"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; var SalesHeader: Record "Sales Header"; var SalesShptHeader: Record "Sales Shipment Header"; var ReturnRcptHeader: Record "Return Receipt Header"; var PostingSalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised before inserting the purchase receipt header for a drop shipment.    /// </summary>    /// <param name="PurchRcptHeader">The purchase receipt header to be inserted.</param>    /// <param name="PurchaseHeader">The source purchase header.</param>    /// <param name="SalesHeader">The related sales header.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="RunOnInsert">Indicates whether to run the OnInsert trigger.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePurchRcptHeaderInsert(var PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchaseHeader: Record "Purchase Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var RunOnInsert: Boolean)    begin    end;    /// <summary>    /// Raised before inserting a purchase receipt line for a drop shipment.    /// </summary>    /// <param name="PurchRcptLine">The purchase receipt line to be inserted.</param>    /// <param name="PurchRcptHeader">The purchase receipt header.</param>    /// <param name="PurchOrderLine">The source purchase order line.</param>    /// <param name="DropShptPostBuffer">The drop shipment posting buffer.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    /// <param name="IsHandled">Set to true to skip the default insertion logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePurchRcptLineInsert(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchOrderLine: Record "Purchase Line"; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer"; CommitIsSuppressed: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before releasing the sales document.    /// </summary>    /// <param name="SalesHeader">The sales header to be released.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeReleaseSalesDocument(SalesHeader: Record "Sales Header"; PreviewMode: Boolean)    begin    end;    /// <summary>    /// Raised before inserting the return receipt header.    /// </summary>    /// <param name="ReturnRcptHeader">The return receipt header to be inserted.</param>    /// <param name="SalesHeader">The source sales header.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeReturnRcptHeaderInsert(var ReturnRcptHeader: Record "Return Receipt Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; WhseShip: Boolean)    begin    end;    /// <summary>    /// Raised before inserting a return receipt line.    /// </summary>    /// <param name="ReturnRcptLine">The return receipt line to be inserted.</param>    /// <param name="ReturnRcptHeader">The return receipt header.</param>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="xSalesLine">The original sales line before modification.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    /// <param name="SalesHeader">The sales header being posted.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeReturnRcptLineInsert(var ReturnRcptLine: Record "Return Receipt Line"; ReturnRcptHeader: Record "Return Receipt Header"; SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; xSalesLine: record "Sales Line"; var TempSalesLineGlobal: record "Sales Line" temporary; var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before posting the job contract line for a sales document.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being posted.</param>    /// <param name="IsHandled">Set to true to skip the default job contract line posting.</param>    /// <param name="JobContractLine">Indicates whether this is a job contract line.</param>    /// <param name="InvoicePostingInterface">The invoice posting interface.</param>    /// <param name="SalesLineACY">The sales line in additional currency.</param>    /// <param name="SalesInvHeader">The posted sales invoice header.</param>    /// <param name="SalesCrMemoHeader">The posted sales credit memo header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostJobContractLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean; var JobContractLine: Boolean; var InvoicePostingInterface: Interface "Invoice Posting"; SalesLineACY: Record "Sales Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header")    begin    end;    /// <summary>    /// Raised before posting the associated item journal line for drop shipments.    /// </summary>    /// <param name="ItemJournalLine">The item journal line to be posted.</param>    /// <param name="PurchaseLine">The associated purchase line.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="IsHandled">Set to true to skip the default posting logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostAssocItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var PurchaseLine: Record "Purchase Line"; CommitIsSuppressed: Boolean; var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before posting the item journal line for a sales line.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being posted.</param>    /// <param name="QtyToBeShipped">The quantity to be shipped.</param>    /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param>    /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param>    /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param>    /// <param name="ItemLedgShptEntryNo">The item ledger shipment entry number.</param>    /// <param name="ItemChargeNo">The item charge number.</param>    /// <param name="TrackingSpecification">The tracking specification.</param>    /// <param name="IsATO">Indicates whether this is an assemble-to-order line.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default posting logic.</param>    /// <param name="Result">The result of the posting operation.</param>    /// <param name="TempTrackingSpecification">The temporary tracking specification.</param>    /// <param name="TempHandlingSpecification">The temporary handling specification.</param>    /// <param name="TempValueEntryRelation">The temporary value entry relation.</param>    /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforePostItemJnlLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var QtyToBeShipped: Decimal; var QtyToBeShippedBase: Decimal; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; var ItemLedgShptEntryNo: Integer; var ItemChargeNo: Code[20]; var TrackingSpecification: Record "Tracking Specification"; var IsATO: Boolean; CommitIsSuppressed: Boolean; var IsHandled: Boolean; var Result: Integer; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempHandlingSpecification: Record "Tracking Specification" temporary; var TempValueEntryRelation: Record "Value Entry Relation" temporary; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line")    begin    end;    /// <summary>    /// Raised before copying document fields to the item journal line.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="QtyToBeShipped">The quantity to be shipped.</param>    /// <param name="QtyToBeShippedIsZero">Indicates whether the quantity to be shipped is zero.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforePostItemJnlLineCopyDocumentFields(SalesHeader: Record "Sales Header"; QtyToBeShipped: Decimal; var QtyToBeShippedIsZero: Boolean)    begin    end;    /// <summary>    /// Raised before posting item charges per order.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being posted.</param>    /// <param name="ItemJnlLine2">The item journal line for the item charge.</param>    /// <param name="ItemChargeSalesLine">The sales line containing the item charge.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemChargePerOrder(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var ItemJnlLine2: Record "Item Journal Line"; var ItemChargeSalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised before updating posting numbers for the sales document.    /// </summary>    /// <param name="SalesHeader">The sales header to update.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="ModifyHeader">Indicates whether the header should be modified.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdatePostingNos(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var ModifyHeader: Boolean)    begin    end;    /// <summary>    /// Raised after preparing the item journal line but before posting it.    /// </summary>    /// <param name="ItemJournalLine">The item journal line to be posted.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param>    /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param>    /// <param name="CheckApplFromItemEntry">Indicates whether to check application from item entry.</param>    /// <param name="TrackingSpecification">The tracking specification.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemJnlLineBeforePost(var ItemJournalLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; QtyToBeShippedBase: Decimal; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var CheckApplFromItemEntry: Boolean; var TrackingSpecification: Record "Tracking Specification")    begin    end;    /// <summary>    /// Raised after posting the item journal line warehouse line.    /// </summary>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="ItemLedgEntryNo">The item ledger entry number.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemJnlLineWhseLine(SalesLine: Record "Sales Line"; ItemLedgEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised after posting item tracking for return receipt.    /// </summary>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="SalesShipmentLine">The sales shipment line.</param>    /// <param name="TempTrackingSpecification">The temporary tracking specification.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    /// <param name="ReturnReceiptLine">The return receipt line.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param>    /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemTrackingReturnRcpt(var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesShipmentLine: Record "Sales Shipment Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptLine: Record "Return Receipt Line"; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    begin    end;    /// <summary>    /// Raised after posting item tracking for shipment.    /// </summary>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="SalesShipmentLine">The sales shipment line.</param>    /// <param name="TempTrackingSpecification">The temporary tracking specification.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param>    /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemTrackingForShipment(var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesShipmentLine: Record "Sales Shipment Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    begin    end;    /// <summary>    /// Raised after posting the item line.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being posted.</param>    /// <param name="QtyToInvoice">The quantity to invoice.</param>    /// <param name="QtyToInvoiceBase">The quantity to invoice in base unit of measure.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyToInvoice: Decimal; QtyToInvoiceBase: Decimal; CommitIsSuppressed: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line")    begin    end;    /// <summary>    /// Raised after posting an item charge.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being posted.</param>    /// <param name="TempItemChargeAssignmentSales">The temporary item charge assignment.</param>    /// <param name="ItemLedgEntryNo">The item ledger entry number.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemCharge(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; ItemLedgEntryNo: Integer)    begin    end;    /// <summary>    /// Raised after testing the sales line for posting readiness.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line that was tested.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterTestSalesLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised after updating and modifying the temporary order line during post update.    /// </summary>    /// <param name="SalesLine">The sales line that was modified.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="SalesHeader">The sales header being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostUpdateOrderLineModifyTempLine(SalesLine: Record "Sales Line"; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after posting G/L entries and customer ledger entries.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param>    /// <param name="TotalSalesLine">The total sales line amounts.</param>    /// <param name="TotalSalesLineLCY">The total sales line amounts in local currency.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="WhseShptHeader">The warehouse shipment header.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    /// <param name="SalesInvHeader">The posted sales invoice header.</param>    /// <param name="SalesCrMemoHeader">The posted sales credit memo header.</param>    /// <param name="CustLedgEntry">The customer ledger entry that was created.</param>    /// <param name="SrcCode">The source code.</param>    /// <param name="GenJnlLineDocNo">The general journal line document number.</param>    /// <param name="GenJnlLineExtDocNo">The general journal line external document number.</param>    /// <param name="GenJnlLineDocType">The general journal line document type.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="DropShipOrder">Indicates whether this is a drop shipment order.</param>    [IntegrationEvent(true, false)]    local procedure OnAfterPostGLAndCustomer(var SalesHeader: Record "Sales Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; TotalSalesLine: Record "Sales Line"; TotalSalesLineLCY: Record "Sales Line"; CommitIsSuppressed: Boolean;        WhseShptHeader: Record "Warehouse Shipment Header"; WhseShip: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header"; var SalesInvHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header";        var CustLedgEntry: Record "Cust. Ledger Entry"; var SrcCode: Code[10]; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; var GenJnlLineDocType: Enum "Gen. Journal Document Type"; PreviewMode: Boolean; DropShipOrder: Boolean)    begin    end;    /// <summary>    /// Raised after posting the resource journal line.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being posted.</param>    /// <param name="JobTaskSalesLine">The job task sales line.</param>    /// <param name="ResJnlLine">The resource journal line that was posted.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostResJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; JobTaskSalesLine: Record "Sales Line"; ResJnlLine: Record "Res. Journal Line")    begin    end;    /// <summary>    /// Raised after reversing the amount on a sales line.    /// </summary>    /// <param name="SalesLine">The sales line with reversed amounts.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterReverseAmount(var SalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised after dividing amounts on a sales line for VAT calculation.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesLine">The sales line with divided amounts.</param>    /// <param name="QtyType">The quantity type (General, Invoicing, or Shipping).</param>    /// <param name="SalesLineQty">The sales line quantity.</param>    /// <param name="TempVATAmountLine">The temporary VAT amount line.</param>    /// <param name="TempVATAmountLineRemainder">The temporary VAT amount line remainder.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterDivideAmount(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; SalesLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary)    begin    end;    /// <summary>    /// Raised after rounding amounts on a sales line.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesLine">The sales line with rounded amounts.</param>    /// <param name="SalesLineQty">The sales line quantity.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterRoundAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal)    begin    end;    /// <summary>    /// Raised after updating the blanket order line.    /// </summary>    /// <param name="BlanketOrderSalesLine">The blanket order sales line that was updated.</param>    /// <param name="SalesLine">The sales line used to update the blanket order.</param>    /// <param name="Ship">Indicates whether the document is being shipped.</param>    /// <param name="Receive">Indicates whether the document is being received.</param>    /// <param name="Invoice">Indicates whether the document is being invoiced.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateBlanketOrderLine(var BlanketOrderSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean)    begin    end;    /// <summary>    /// Raised after updating the prepayment sales line with rounding.    /// </summary>    /// <param name="PrepmtSalesLine">The prepayment sales line that was updated.</param>    /// <param name="TotalRoundingAmount">The total rounding amounts.</param>    /// <param name="TotalPrepmtAmount">The total prepayment amounts.</param>    /// <param name="FinalInvoice">Indicates whether this is the final invoice.</param>    /// <param name="PricesInclVATRoundingAmount">The prices including VAT rounding amounts.</param>    /// <param name="TotalSalesLine">The total sales line amounts.</param>    /// <param name="TotalSalesLineLCY">The total sales line amounts in local currency.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdatePrepmtSalesLineWithRounding(var PrepmtSalesLine: Record "Sales Line"; TotalRoundingAmount: array[2] of Decimal; TotalPrepmtAmount: array[2] of Decimal; FinalInvoice: Boolean; PricesInclVATRoundingAmount: array[2] of Decimal; var TotalSalesLine: Record "Sales Line"; var TotalSalesLineLCY: Record "Sales Line")    begin    end;    /// <summary>    /// Raised after updating warehouse documents.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="WhseShptHeader">The warehouse shipment header.</param>    /// <param name="WhseRcptHeader">The warehouse receipt header.</param>    /// <param name="EverythingInvoiced">Indicates whether everything has been invoiced.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateWhseDocuments(SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; WhseShptHeader: Record "Warehouse Shipment Header"; WhseRcptHeader: Record "Warehouse Receipt Header"; EverythingInvoiced: Boolean)    begin    end;    /// <summary>    /// Raised after updating associated order posting numbers.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="TempSalesLine">The temporary sales lines.</param>    /// <param name="DropShipment">Indicates whether this is a drop shipment.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateAssosOrderPostingNos(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var DropShipment: Boolean)    begin    end;    /// <summary>    /// Raised after releasing the sales document.    /// </summary>    /// <param name="SalesHeader">The sales header that was released.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterReleaseSalesDoc(var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after validating the posting and document dates.    /// </summary>    /// <param name="SalesHeader">The sales header that was validated.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="ReplacePostingDate">Indicates whether the posting date should be replaced.</param>    /// <param name="ReplaceDocumentDate">Indicates whether the document date should be replaced.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterValidatePostingAndDocumentDate(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; PreviewMode: Boolean; ReplacePostingDate: Boolean; ReplaceDocumentDate: Boolean)    begin    end;    /// <summary>    /// Raised before calculating the invoice.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    /// <param name="NewInvoice">Indicates whether a new invoice will be created.</param>    /// <param name="IsHandled">Set to true to skip the default calculation logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcInvoice(SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var NewInvoice: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before calculating item journal line amounts from quantity to be shipped.    /// </summary>    /// <param name="ItemJnlLine">The item journal line.</param>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="QtyToBeShipped">The quantity to be shipped.</param>    /// <param name="IsHandled">Set to true to skip the default calculation logic.</param>    /// <param name="InvDiscAmountPerShippedQty">The invoice discount amount per shipped quantity.</param>    /// <param name="RemAmt">The remaining amount.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcItemJnlAmountsFromQtyToBeShipped(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; var IsHandled: Boolean; var InvDiscAmountPerShippedQty: Decimal; RemAmt: Decimal)    begin    end;    /// <summary>    /// Raised before checking associated order lines.    /// </summary>    /// <param name="SalesHeader">The sales header being checked.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckAssosOrderLines(SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking customer blockage.    /// </summary>    /// <param name="SalesHeader">The sales header being checked.</param>    /// <param name="CustCode">The customer code to check.</param>    /// <param name="ExecuteDocCheck">Indicates whether to execute document check.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    /// <param name="TempSalesLine">The temporary sales lines.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckCustBlockage(SalesHeader: Record "Sales Header"; CustCode: Code[20]; var ExecuteDocCheck: Boolean; var IsHandled: Boolean; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised before checking if job number on shipment line equals sales line.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckJobNoOnShptLineEqualToSales(SalesShipmentLine: Record "Sales Shipment Line"; SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking G/L account direct posting settings.    /// </summary>    /// <param name="SalesLine">The sales line to check.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckGLAccountDirectPosting(SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking whether to insert the return receipt header.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckInsertReturnReceiptHeader(SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking item reservation disruption.    /// </summary>    /// <param name="SalesLine">The sales line to check.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckItemReservDisruption(SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking mandatory header fields.    /// </summary>    /// <param name="SalesHeader">The sales header to check.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckMandatoryHeaderFields(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking whether to post warehouse receipt line from shipment line.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPostWhseRcptLineFromShipmentLine(var SalesShptLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking whether to post warehouse shipment lines.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    /// <param name="WhseShptHeader">The warehouse shipment header.</param>    /// <param name="WhseRcptHeader">The warehouse receipt header.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPostWhseShptLines(var SalesShptLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean; WhseShptHeader: Record "Warehouse Shipment Header"; WhseRcptHeader: Record "Warehouse Receipt Header"; WhseShip: Boolean; WhseReceive: Boolean)    begin    end;    /// <summary>    /// Raised before checking posting flags.    /// </summary>    /// <param name="SalesHeader">The sales header to check.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPostingFlags(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking prepayment amount to deduct.    /// </summary>    /// <param name="TempSalesLine">The temporary sales lines.</param>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    /// <param name="Fraction">The fraction for calculation.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPrepmtAmtToDeduct(var TempSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; Fraction: Decimal)    begin    end;    /// <summary>    /// Raised before checking header shipping advice.    /// </summary>    /// <param name="SalesHeader">The sales header to check.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckHeaderShippingAdvice(SalesHeader: Record "Sales Header"; WhseShip: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking header posting type.    /// </summary>    /// <param name="SalesHeader">The sales header to check.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckHeaderPostingType(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking if sales line is invoiced more than shipped.    /// </summary>    /// <param name="SalesOrderLine">The sales order line.</param>    /// <param name="TempSalesLine">The temporary sales line.</param>    /// <param name="SalesShptLine">The sales shipment line.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckSalesLineInvoiceMoreThanShipped(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary; var SalesShptLine: Record "Sales Shipment Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking the total invoice amount.    /// </summary>    /// <param name="SalesHeader">The sales header to check.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckTotalInvoiceAmount(SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking the total prepayment amount to deduct.    /// </summary>    /// <param name="TempSalesLine">The temporary sales line.</param>    /// <param name="TempTotalSalesLine">The temporary total sales line.</param>    /// <param name="MaxAmtToDeduct">The maximum amount to deduct.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckTotalPrepmtAmtToDeduct(var TempSalesLine: Record "Sales Line" temporary; var TempTotalSalesLine: Record "Sales Line" temporary; var MaxAmtToDeduct: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking warehouse requirements.    /// </summary>    /// <param name="TempItemSalesLine">The temporary item sales line.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckWarehouse(var TempItemSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before clearing remaining amount if not item journal roll rounding.    /// </summary>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="ItemJnlRollRndg">Indicates whether item journal roll rounding is used.</param>    /// <param name="RemAmt">The remaining amount.</param>    /// <param name="RemDiscAmt">The remaining discount amount.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeClearRemAmtIfNotItemJnlRollRndg(SalesLine: Record "Sales Line"; ItemJnlRollRndg: Boolean; var RemAmt: Decimal; var RemDiscAmt: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before dividing amounts on a sales line for VAT calculation.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesLine">The sales line to process.</param>    /// <param name="QtyType">The quantity type (General, Invoicing, or Shipping).</param>    /// <param name="SalesLineQty">The sales line quantity.</param>    /// <param name="TempVATAmountLine">The temporary VAT amount line.</param>    /// <param name="TempVATAmountLineRemainder">The temporary VAT amount line remainder.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="TempPrepmtDeductLCYSalesLine">The temporary prepayment deduct LCY sales line.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeDivideAmount(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; var SalesLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; var IsHandled: Boolean; var TempPrepmtDeductLCYSalesLine: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised before initializing line amount and line discount amount during divide amount.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesLine">The sales line to process.</param>    /// <param name="SalesLineQty">The sales line quantity.</param>    /// <param name="IncludePrepayments">Indicates whether to include prepayments.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="TempPrepmtDeductLCYSalesLine">The temporary prepayment deduct LCY sales line.</param>    /// <param name="TempVATAmountLine">The temporary VAT amount line.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforeDivideAmountInitLineAmountAndLineDiscountAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesLineQty: Decimal; IncludePrepayments: Boolean; var IsHandled: Boolean; var TempPrepmtDeductLCYSalesLine: Record "Sales Line" temporary; var TempVATAmountLine: Record "VAT Amount Line" temporary)    begin    end;    /// <summary>    /// Raised before getting the invoice posting setup.    /// </summary>    /// <param name="InvoicePostingInterface">The invoice posting interface.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetInvoicePostingSetup(var InvoicePostingInterface: Interface "Invoice Posting"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before rounding amounts on a sales line.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="SalesLine">The sales line to round.</param>    /// <param name="SalesLineQty">The sales line quantity.</param>    /// <param name="CurrExchRate">The currency exchange rate.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeRoundAmount(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesLineQty: Decimal; var CurrExchRate: Record "Currency Exchange Rate")    begin    end;    /// <summary>    /// Raised before posting assemble-to-order.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being posted.</param>    /// <param name="TempPostedATOLink">The temporary posted assemble-to-order link.</param>    /// <param name="AsmPost">The assembly post codeunit instance.</param>    /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param>    /// <param name="ResJnlPostLine">The resource journal post line codeunit instance.</param>    /// <param name="WhseJnlPostLine">The warehouse journal register line codeunit instance.</param>    /// <param name="HideProgressWindow">Indicates whether to hide the progress window.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostATO(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary; var AsmPost: Codeunit "Assembly-Post"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var ResJnlPostLine: Codeunit "Res. Jnl.-Post Line"; var WhseJnlPostLine: Codeunit "Whse. Jnl.-Register Line"; HideProgressWindow: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before posting the drop shipment order.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="TempDropShptPostBuffer">The temporary drop shipment post buffer.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostDropOrderShipment(var SalesHeader: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    /// <summary>    /// Raised before posting the invoice.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="CustLedgerEntry">The customer ledger entry to be created.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="GenJnlLineDocNo">The general journal line document number.</param>    /// <param name="GenJnlLineExtDocNo">The general journal line external document number.</param>    /// <param name="GenJnlLineDocType">The general journal line document type.</param>    /// <param name="SrcCode">The source code.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostInvoice(var SalesHeader: Record "Sales Header"; var CustLedgerEntry: Record "Cust. Ledger Entry"; CommitIsSuppressed: Boolean; PreviewMode: Boolean; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var IsHandled: Boolean; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; SrcCode: Code[10])    begin    end;    /// <summary>    /// Raised before posting an item charge.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line containing the item charge.</param>    /// <param name="TempItemChargeAssignmentSales">The temporary item charge assignment.</param>    /// <param name="ItemLedgEntryNo">The item ledger entry number.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemCharge(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; ItemLedgEntryNo: Integer)    begin    end;    /// <summary>    /// Raised before posting item tracking.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being posted.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param>    /// <param name="TempTrackingSpecification">The temporary tracking specification.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="TempItemLedgEntryNotInvoiced">The temporary item ledger entries not invoiced.</param>    /// <param name="HasATOShippedNotInvoiced">Indicates whether ATO has been shipped but not invoiced.</param>    /// <param name="PreciseTotalChargeAmt">The precise total charge amount.</param>    /// <param name="RoundedPrevTotalChargeAmt">The rounded previous total charge amount.</param>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    /// <param name="ItemJnlRollRndg">Indicates whether item journal roll rounding is used.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforePostItemTracking(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean; TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean; var PreciseTotalChargeAmt: Decimal; var RoundedPrevTotalChargeAmt: Decimal; RemQtyToBeInvoiced: Decimal; var ItemJnlRollRndg: Boolean)    begin    end;    /// <summary>    /// Raised before checking item tracking for return receipt posting.    /// </summary>    /// <param name="SalesLine">The sales line being checked.</param>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforePostItemTrackingCheckReturnReceipt(SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before checking item tracking for shipment posting.    /// </summary>    /// <param name="SalesLine">The sales line being checked.</param>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforePostItemTrackingCheckShipment(SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before posting item tracking for return receipt.    /// </summary>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="SalesShipmentLine">The sales shipment line.</param>    /// <param name="TempTrackingSpecification">The temporary tracking specification.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    /// <param name="ReturnReceiptLine">The return receipt line.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param>    /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingReturnRcpt(var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesShipmentLine: Record "Sales Shipment Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptLine: Record "Return Receipt Line"; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    begin    end;    /// <summary>    /// Raised before posting item tracking for shipment.    /// </summary>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="SalesShipmentLine">The sales shipment line.</param>    /// <param name="TempTrackingSpecification">The temporary tracking specification.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param>    /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingForShipment(var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesShipmentLine: Record "Sales Shipment Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    begin    end;    /// <summary>    /// Raised before posting the resource journal line.    /// </summary>    /// <param name="SalesHeader">The sales header being posted.</param>    /// <param name="SalesLine">The sales line being posted.</param>    /// <param name="JobTaskSalesLine">The job task sales line.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="DocNo">The document number.</param>    /// <param name="ExtDocNo">The external document number.</param>    /// <param name="SourceCode">The source code.</param>    /// <param name="SalesShptHeader">The sales shipment header.</param>    /// <param name="ReturnRcptHeader">The return receipt header.</param>    /// <param name="ResJnlPostLine">The resource journal post line codeunit instance.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostResJnlLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var JobTaskSalesLine: Record "Sales Line"; var IsHandled: Boolean; DocNo: Code[20]; ExtDocNo: Code[35]; SourceCode: Code[10]; SalesShptHeader: Record "Sales Shipment Header"; ReturnRcptHeader: Record "Return Receipt Header"; var ResJnlPostLine: Codeunit "Res. Jnl.-Post Line")    begin    end;    /// <summary>    /// Raised before updating the order line during post processing.    /// </summary>    /// <param name="SalesHeader">The sales header being processed.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="SalesSetup">The sales and receivables setup.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostUpdateOrderLine(SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; CommitIsSuppressed: Boolean; var SalesSetup: Record "Sales & Receivables Setup")    begin    end;    /// <summary>    /// Raised before modifying the temporary order line during post update.    /// </summary>    /// <param name="TempSalesLine">The temporary sales line.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="SalesHeader">The sales header being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostUpdateOrderLineModifyTempLine(var TempSalesLine: Record "Sales Line" temporary; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; var IsHandled: Boolean; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before posting warehouse receipt line from shipment line.    /// </summary>    /// <param name="WhseRcptLine">The warehouse receipt line.</param>    /// <param name="SalesShptLine">The sales shipment line.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="PostedWhseRcptHeader">The posted warehouse receipt header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostWhseRcptLineFromShipmentLine(var WhseRcptLine: Record "Warehouse Receipt Line"; SalesShptLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean; PostedWhseRcptHeader: Record "Posted Whse. Receipt Header")    begin    end;    /// <summary>    /// Raised before validating posting and document dates.    /// </summary>    /// <param name="SalesHeader">The sales header to validate.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default validation logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeValidatePostingAndDocumentDate(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before updating invoiced quantity on shipment line.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line to update.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateInvoicedQtyOnShipmentLine(var SalesShipmentLine: Record "Sales Shipment Line"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised before the update invoiced quantity on shipment line procedure.    /// </summary>    /// <param name="SalesShptLine">The sales shipment line to update.</param>    /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param>    /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateInvoicedQtyOnShipmentLineProcedure(var SalesShptLine: Record "Sales Shipment Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    begin    end;    /// <summary>    /// Raised before sending the intercompany document.    /// </summary>    /// <param name="SalesHeader">The sales header to send.</param>    /// <param name="ModifyHeader">Indicates whether the header should be modified.</param>    /// <param name="IsHandled">Set to true to skip the default send logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSendICDocument(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before setting posting flags.    /// </summary>    /// <param name="SalesHeader">The sales header to set flags for.</param>    /// <param name="IsHandled">Set to true to skip the default flag setting logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSetPostingFlags(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before testing fields by document type.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesLine">The sales line to test.</param>    /// <param name="IsHandled">Set to true to skip the default test logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTestFieldsByDocType(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before testing the sales line for posting readiness.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesLine">The sales line to test.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="IsHandled">Set to true to skip the default test logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTestSalesLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before testing the sales line for fixed asset posting.    /// </summary>    /// <param name="SalesLine">The sales line to test.</param>    /// <param name="IsHandled">Set to true to skip the default test logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTestSalesLineFixedAsset(SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before testing the sales line for item charge posting.    /// </summary>    /// <param name="SalesLine">The sales line to test.</param>    /// <param name="IsHandled">Set to true to skip the default test logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTestSalesLineItemCharge(SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before testing the sales line for job posting.    /// </summary>    /// <param name="SalesLine">The sales line to test.</param>    /// <param name="SkipTestJobNo">Set to true to skip the job number test.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTestSalesLineJob(SalesLine: Record "Sales Line"; var SkipTestJobNo: Boolean)    begin    end;    /// <summary>    /// Raised before testing the updated sales line.    /// </summary>    /// <param name="SalesLine">The sales line to test.</param>    /// <param name="IsHandled">Set to true to skip the default test logic.</param>    /// <param name="ErrorMessageManagement">The error message management codeunit for handling errors.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTestUpdatedSalesLine(SalesLine: Record "Sales Line"; var IsHandled: Boolean; var ErrorMessageManagement: Codeunit "Error Message Management")    begin    end;    /// <summary>    /// Raised before testing the sales line for other posting scenarios.    /// </summary>    /// <param name="SalesLine">The sales line to test.</param>    /// <param name="SkipTestJobNo">Set to true to skip the job number test.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTestSalesLineOthers(SalesLine: Record "Sales Line"; var SkipTestJobNo: Boolean)    begin    end;    /// <summary>    /// Raised before testing the status for release.    /// </summary>    /// <param name="SalesHeader">The sales header to test.</param>    /// <param name="IsHandled">Set to true to skip the default status test logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTestStatusRelease(SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before inserting the temporary prepayment sales line.    /// </summary>    /// <param name="TempPrepmtSalesLine">The temporary prepayment sales line to insert.</param>    /// <param name="TempSalesLine">The temporary sales line.</param>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="CompleteFunctionality">Indicates whether to use complete functionality.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTempPrepmtSalesLineInsert(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean)    begin    end;    /// <summary>    /// Raised before modifying the temporary prepayment sales line.    /// </summary>    /// <param name="TempPrepmtSalesLine">The temporary prepayment sales line to modify.</param>    /// <param name="TempSalesLine">The temporary sales line.</param>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="CompleteFunctionality">Indicates whether to use complete functionality.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTempPrepmtSalesLineModify(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean)    begin    end;    /// <summary>    /// Raised before transferring reservation to item journal line.    /// </summary>    /// <param name="SalesOrderLine">The sales order line.</param>    /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param>    /// <param name="IsHandled">Set to true to skip the default transfer logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTransferReservToItemJnlLine(var SalesOrderLine: Record "Sales Line"; var QtyToBeShippedBase: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before releasing the sales document.    /// </summary>    /// <param name="SalesHeader">The sales header to release.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeReleaseSalesDoc(var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before updating associated order posting numbers.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="DropShipment">Indicates whether this is a drop shipment.</param>    /// <param name="IsHandled">Set to true to skip the default update logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateAssosOrderPostingNos(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; PreviewMode: Boolean; var DropShipment: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before updating associated lines.    /// </summary>    /// <param name="SalesOrderLine">The sales order line.</param>    /// <param name="IsHandled">Set to true to skip the default update logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateAssocLines(var SalesOrderLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before updating the blanket order line.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="Ship">Indicates whether the document is being shipped.</param>    /// <param name="Receive">Indicates whether the document is being received.</param>    /// <param name="Invoice">Indicates whether the document is being invoiced.</param>    /// <param name="IsHandled">Set to true to skip the default update logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateBlanketOrderLine(SalesLine: Record "Sales Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before updating the handled intercompany inbox transaction.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="IsHandled">Set to true to skip the default update logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateHandledICInboxTransaction(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before updating the posting number.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="ModifyHeader">Indicates whether the header should be modified.</param>    /// <param name="IsHandled">Set to true to skip the default update logic.</param>    /// <param name="DateOrderSeriesUsed">Indicates whether date order series is used.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdatePostingNo(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean; var ModifyHeader: Boolean; var IsHandled: Boolean; var DateOrderSeriesUsed: Boolean)    begin    end;    /// <summary>    /// Raised before updating the prepayment sales line with rounding.    /// </summary>    /// <param name="PrepmtSalesLine">The prepayment sales line.</param>    /// <param name="TotalRoundingAmount">The total rounding amounts.</param>    /// <param name="TotalPrepmtAmount">The total prepayment amounts.</param>    /// <param name="FinalInvoice">Indicates whether this is the final invoice.</param>    /// <param name="PricesInclVATRoundingAmount">The prices including VAT rounding amounts.</param>    /// <param name="TotalSalesLine">The total sales line amounts.</param>    /// <param name="TotalSalesLineLCY">The total sales line amounts in local currency.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdatePrepmtSalesLineWithRounding(var PrepmtSalesLine: Record "Sales Line"; TotalRoundingAmount: array[2] of Decimal; TotalPrepmtAmount: array[2] of Decimal; FinalInvoice: Boolean; PricesInclVATRoundingAmount: array[2] of Decimal; var TotalSalesLine: Record "Sales Line"; var TotalSalesLineLCY: Record "Sales Line")    begin    end;    /// <summary>    /// Raised before updating quantity to be invoiced for shipment.    /// </summary>    /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param>    /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param>    /// <param name="HasATOShippedNotInvoiced">Indicates whether ATO has been shipped but not invoiced.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="SalesShptLine">The sales shipment line.</param>    /// <param name="InvoicingTrackingSpecification">The invoicing tracking specification.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateQtyToBeInvoicedForShipment(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; HasATOShippedNotInvoiced: Boolean; SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; InvoicingTrackingSpecification: Record "Tracking Specification")    begin    end;    /// <summary>    /// Raised before updating quantity to be invoiced for return receipt.    /// </summary>    /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param>    /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="ReturnReceiptLine">The return receipt line.</param>    /// <param name="InvoicingTrackingSpecification">The invoicing tracking specification.</param>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    /// <param name="RemQtyToBeInvoicedBase">The remaining quantity to be invoiced in base unit of measure.</param>    /// <param name="IsHandled">Set to true to skip the default update logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateQtyToBeInvoicedForReturnReceipt(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; SalesLine: Record "Sales Line"; ReturnReceiptLine: Record "Return Receipt Line"; InvoicingTrackingSpecification: Record "Tracking Specification"; RemQtyToBeInvoiced: Decimal; RemQtyToBeInvoicedBase: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before updating the return receipt number.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="ModifyHeader">Indicates whether the header should be modified.</param>    /// <param name="IsHandled">Set to true to skip the default update logic.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateReturnReceiptNo(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean; var IsHandled: Boolean; PreviewMode: Boolean)    begin    end;    /// <summary>    /// Raised before updating the sales header.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry.</param>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    /// <param name="GenJnlLineDocType">The general journal line document type.</param>    /// <param name="IsHandled">Set to true to skip the default update logic.</param>    /// <param name="GenJnlLineDocNo">The general journal line document number.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="SalesHeader">The sales header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateSalesHeader(var CustLedgerEntry: Record "Cust. Ledger Entry"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; GenJnlLineDocType: Option; var IsHandled: Boolean; GenJnlLineDocNo: Code[20]; PreviewMode: Boolean; var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before updating the sales line before posting.    /// </summary>    /// <param name="SalesLine">The sales line to update.</param>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="RoundingLineInserted">Indicates whether a rounding line was inserted.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateSalesLineBeforePost(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; RoundingLineInserted: Boolean; CommitIsSuppressed: Boolean)    begin    end;    /// <summary>    /// Raised before updating the shipping number.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="InvtPickPutaway">Indicates whether inventory pick/put-away is involved.</param>    /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param>    /// <param name="ModifyHeader">Indicates whether the header should be modified.</param>    /// <param name="IsHandled">Set to true to skip the default update logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateShippingNo(var SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; InvtPickPutaway: Boolean; PreviewMode: Boolean; var ModifyHeader: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before updating warehouse documents.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="IsHandled">Set to true to skip the default update logic.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseRcptHeader">The warehouse receipt header.</param>    /// <param name="WhseShptHeader">The warehouse shipment header.</param>    /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param>    /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateWhseDocuments(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; WhseReceive: Boolean; WhseShip: Boolean; WhseRcptHeader: Record "Warehouse Receipt Header"; WhseShptHeader: Record "Warehouse Shipment Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary)    begin    end;    /// <summary>    /// Raised before determining if warehouse handling is required.    /// </summary>    /// <param name="SalesLine">The sales line to check.</param>    /// <param name="Required">Indicates whether warehouse handling is required.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeWhseHandlingRequired(SalesLine: Record "Sales Line"; var Required: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised when invoicing a sales shipment line.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line being invoiced.</param>    /// <param name="InvoiceNo">The invoice number.</param>    /// <param name="InvoiceLineNo">The invoice line number.</param>    /// <param name="QtyToInvoice">The quantity to invoice.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnInvoiceSalesShptLine(SalesShipmentLine: Record "Sales Shipment Line"; InvoiceNo: Code[20]; InvoiceLineNo: Integer; QtyToInvoice: Decimal; CommitIsSuppressed: Boolean)    begin    end;    local procedure PostResJnlLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var JobTaskSalesLine2: Record "Sales Line")    var        ResJnlLine: Record "Res. Journal Line";        IsHandled: Boolean;        ShouldExit: Boolean;    begin        IsHandled := false;        OnBeforePostResJnlLine(SalesHeader, SalesLine, JobTaskSalesLine2, IsHandled, GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesShptHeader, ReturnRcptHeader, ResJnlPostLine);        if IsHandled then            exit;        ShouldExit := SalesLine."Qty. to Invoice" = 0;        OnPostResJnlLineOnShouldExit(SalesLine, ShouldExit);        if ShouldExit then            exit;        ResJnlLine.Init();        ResJnlLine.CopyFromSalesHeader(SalesHeader);        ResJnlLine.CopyDocumentFields(GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series");        ResJnlLine.CopyFromSalesLine(SalesLine);        OnPostResJnlLineOnAfterInit(ResJnlLine, SalesLine);        ResJnlPostLine.RunWithCheck(ResJnlLine);        if JobTaskSalesLine2."Job Contract Entry No." > 0 then            PostJobContractLine(SalesHeader, JobTaskSalesLine2);        OnAfterPostResJnlLine(SalesHeader, SalesLine, JobTaskSalesLine2, ResJnlLine);    end;    local procedure ValidatePostingAndDocumentDate(var SalesHeader: Record "Sales Header")    var        BatchProcessingMgt: Codeunit "Batch Processing Mgt.";        PostingDate, VATDate : Date;        ModifyHeader: Boolean;        PostingDateExists, VATDateExists : Boolean;        ReplacePostingDate: Boolean;        ReplaceDocumentDate: Boolean;        ReplaceVATDate: Boolean;        SkipTestPostingDate: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeValidatePostingAndDocumentDate(SalesHeader, SuppressCommit, IsHandled);        if IsHandled then            exit;        PostingDateExists :=          BatchProcessingMgt.GetBooleanParameter(SalesHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Replace Posting Date", ReplacePostingDate) and          BatchProcessingMgt.GetBooleanParameter(            SalesHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Replace Document Date", ReplaceDocumentDate) and          BatchProcessingMgt.GetDateParameter(SalesHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Posting Date", PostingDate);        VATDateExists := BatchProcessingMgt.GetBooleanParameter(SalesHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Replace VAT Date", ReplaceVATDate);        BatchProcessingMgt.GetDateParameter(SalesHeader.RecordId, Enum::"Batch Posting Parameter Type"::"VAT Date", VATDate);        OnValidatePostingAndDocumentDateOnAfterCalcPostingDateExists(PostingDateExists, ReplacePostingDate, ReplaceDocumentDate, PostingDate, SalesHeader, ModifyHeader, VATDateExists, ReplaceVATDate, VATDate);        if PostingDateExists and (ReplacePostingDate or (SalesHeader."Posting Date" = 0D)) then begin            SalesHeader."Posting Date" := PostingDate;            SalesHeader.SynchronizeAsmHeader();            SalesHeader.Validate("Currency Code");            ModifyHeader := true;        end;        OnValidatePostingAndDocumentDateOnBeforeValidateDocumentDate(PostingDateExists, ReplaceDocumentDate, PostingDate, SalesHeader);        if PostingDateExists and (ReplaceDocumentDate or (SalesHeader."Document Date" = 0D)) then begin            SalesHeader.Validate("Document Date", PostingDate);            ModifyHeader := true;        end;        if VATDateExists and (ReplaceVATDate) then begin            SalesHeader."VAT Reporting Date" := VATDate;            ModifyHeader := true;        end;        if not ReplacePostingDate then begin            SkipTestPostingDate := false;            OnValidatePostingAndDocumentDateOnBeforeTestPostingDate(SalesHeader, PostingDateExists, SkipTestPostingDate);            if not SkipTestPostingDate then                SalesHeader.TestPostingDate(PostingDateExists);        end;        OnValidatePostingAndDocumentDateOnBeforeSalesHeaderModify(SalesHeader, ModifyHeader);        if ModifyHeader then            SalesHeader.Modify();        OnAfterValidatePostingAndDocumentDate(SalesHeader, SuppressCommit, PreviewMode, ReplacePostingDate, ReplaceDocumentDate);    end;    local procedure UpdateItemJnlLineDimSetIDFromAppliedShipmentEntry(var ItemJnlLine2: Record "Item Journal Line")    var        ItemLedgerEntry: Record "Item Ledger Entry";        DimensionMgt: Codeunit DimensionManagement;        DimSetID: array[10] of Integer;    begin        if ItemJnlLine2."Item Shpt. Entry No." <> 0 then begin            ItemLedgerEntry.SetLoadFields("Dimension Set ID");            ItemLedgerEntry.Get(ItemJnlLine2."Item Shpt. Entry No.");            DimSetID[1] := ItemLedgerEntry."Dimension Set ID";            DimSetID[2] := ItemJnlLine2."Dimension Set ID";            ItemJnlLine2."Dimension Set ID" :=                DimensionMgt.GetCombinedDimensionSetID(DimSetID, ItemJnlLine2."Shortcut Dimension 1 Code", ItemJnlLine2."Shortcut Dimension 2 Code");        end;    end;    local procedure UpdateSalesLineDimSetIDFromAppliedEntry(var SalesLineToPost: Record "Sales Line"; SalesLine: Record "Sales Line")    var        ItemLedgEntry: Record "Item Ledger Entry";        DimensionMgt: Codeunit DimensionManagement;        DimSetID: array[10] of Integer;    begin        DimSetID[1] := SalesLine."Dimension Set ID";        if SalesLineToPost."Appl.-to Item Entry" <> 0 then begin            ItemLedgEntry.Get(SalesLineToPost."Appl.-to Item Entry");            DimSetID[2] := ItemLedgEntry."Dimension Set ID";        end;        SalesLineToPost."Dimension Set ID" :=          DimensionMgt.GetCombinedDimensionSetID(DimSetID, SalesLineToPost."Shortcut Dimension 1 Code", SalesLineToPost."Shortcut Dimension 2 Code");        OnAfterUpdateSalesLineDimSetIDFromAppliedEntry(SalesLineToPost, ItemLedgEntry, DimSetID);    end;    /// <summary>    /// Raised when sending the sales document.    /// </summary>    /// <param name="ShipAndInvoice">Indicates whether to ship and invoice.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    [IntegrationEvent(false, false)]    local procedure OnSendSalesDocument(ShipAndInvoice: Boolean; CommitIsSuppressed: Boolean)    begin    end;    local procedure GetAmountRoundingPrecisionInLCY(DocType: Enum "Sales Document Type"; DocNo: Code[20]; CurrencyCode: Code[10]) AmountRoundingPrecision: Decimal    var        SalesHeader: Record "Sales Header";    begin        if CurrencyCode = '' then            exit(GLSetup."Amount Rounding Precision");        SalesHeader.Get(DocType, DocNo);        AmountRoundingPrecision := Currency."Amount Rounding Precision" / SalesHeader."Currency Factor";        if AmountRoundingPrecision < GLSetup."Amount Rounding Precision" then            exit(GLSetup."Amount Rounding Precision");        exit(AmountRoundingPrecision);    end;    local procedure UpdateEmailParameters(SalesHeader: Record "Sales Header")    var        FindEmailParameter: Record "Email Parameter";        RenameEmailParameter: Record "Email Parameter";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateEmailParameters(SalesHeader, IsHandled);        if IsHandled then            exit;        if SalesHeader."Last Posting No." = '' then            exit;        FindEmailParameter.SetRange("Document No", SalesHeader."No.");        FindEmailParameter.SetRange("Document Type", SalesHeader."Document Type");        if FindEmailParameter.FindSet() then            repeat                RenameEmailParameter.Copy(FindEmailParameter);                RenameEmailParameter.Rename(                  SalesHeader."Last Posting No.", FindEmailParameter."Document Type", FindEmailParameter."Parameter Type");            until FindEmailParameter.Next() = 0;    end;    local procedure ArchivePurchaseOrders(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    var        PurchOrderHeader: Record "Purchase Header";        PurchOrderLine: Record "Purchase Line";    begin        if TempDropShptPostBuffer.FindSet() then            repeat                PurchOrderHeader.Get(PurchOrderHeader."Document Type"::Order, TempDropShptPostBuffer."Order No.");                TempDropShptPostBuffer.SetRange("Order No.", TempDropShptPostBuffer."Order No.");                repeat                    PurchOrderLine.Get(                      PurchOrderLine."Document Type"::Order,                      TempDropShptPostBuffer."Order No.", TempDropShptPostBuffer."Order Line No.");                    PurchOrderLine."Qty. to Receive" := TempDropShptPostBuffer.Quantity;                    PurchOrderLine."Qty. to Receive (Base)" := TempDropShptPostBuffer."Quantity (Base)";                    OnArchivePurchaseOrdersOnBeforePurchOrderLineModify(PurchOrderLine, TempDropShptPostBuffer);                    PurchOrderLine.Modify();                until TempDropShptPostBuffer.Next() = 0;                PurchPost.ArchiveUnpostedOrder(PurchOrderHeader);                TempDropShptPostBuffer.SetRange("Order No.");            until TempDropShptPostBuffer.Next() = 0;    end;    /// <summary>    /// Raises the OnBeforePostResJnlLine event.    /// </summary>    /// <param name="ItemJnlLine">The item journal line that is posted.</param>    /// <param name="SalesLine">The sales line of the document that is posted.</param>    /// <param name="SalesHeader">The sales header of the document that is posted.</param>    /// <returns>Value of the IsHandled variable that is exposed by the event. False by default</returns>    procedure IsItemJnlPostLineHandled(var ItemJnlLine: Record "Item Journal Line"; var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header") IsHandled: Boolean    begin        IsHandled := false;        OnBeforeItemJnlPostLine(ItemJnlLine, SalesLine, SalesHeader, SuppressCommit, IsHandled, TempItemChargeAssgntSales);        exit(IsHandled);    end;    local procedure CalcVATBaseAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcVATBaseAmount(SalesHeader, SalesLine, TempVATAmountLine, TempVATAmountLineRemainder, Currency, IsHandled);        if IsHandled then            exit;        SalesLine."VAT Base Amount" :=          Round(            SalesLine.Amount * (1 - SalesLine.GetVatBaseDiscountPct(SalesHeader) / 100), Currency."Amount Rounding Precision");    end;    local procedure SalesShptLineInsert(var SalesShptLine: Record "Sales Shipment Line"; SalesShptHeader: Record "Sales Shipment Header"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSalesShptLineInsert(            SalesShptLine, SalesShptHeader, SalesLine, SuppressCommit, PostedWhseShptLine, SalesHeader, WhseShip, WhseReceive,            ItemLedgShptEntryNo, xSalesLine, TempSalesLineGlobal, IsHandled);        if IsHandled then            exit;        SalesShptLine.Insert(true);        OnAfterSalesShptLineInsert(SalesShptLine, SalesLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit, SalesInvHeader, TempWhseShptHeader, TempWhseRcptHeader, SalesShptHeader, SalesHeader);    end;    local procedure SalesInvHeaderInsert(var SalesInvHeader: Record "Sales Invoice Header"; var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSalesInvHeaderInsert(SalesInvHeader, SalesHeader, SuppressCommit, IsHandled, WhseShip, WhseShptHeader, InvtPickPutaway);        if IsHandled then            exit;        SalesInvHeader.Insert(true);        OnAfterSalesInvHeaderInsert(SalesInvHeader, SalesHeader, SuppressCommit, WhseShip, WhseReceive, TempWhseShptHeader, TempWhseRcptHeader, PreviewMode);    end;    local procedure SalesShptHeaderInsert(var SalesShptHeader: Record "Sales Shipment Header"; var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSalesShptHeaderInsert(SalesShptHeader, SalesHeader, SuppressCommit, IsHandled, TempWhseRcptHeader, WhseReceive, TempWhseShptHeader, WhseShip, InvtPickPutaway);        if IsHandled then            exit;        SalesShptHeader.Insert(true);        OnAfterSalesShptHeaderInsert(SalesShptHeader, SalesHeader, SuppressCommit, WhseShip, WhseReceive, TempWhseShptHeader, TempWhseRcptHeader, PreviewMode);    end;    local procedure SalesCrMemoHeaderInsert(var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSalesCrMemoHeaderInsert(SalesCrMemoHeader, SalesHeader, SuppressCommit, IsHandled, SalesInvHeader);        if IsHandled then            exit;        SalesCrMemoHeader.Insert(true);        OnAfterSalesCrMemoHeaderInsert(SalesCrMemoHeader, SalesHeader, SuppressCommit, WhseShip, WhseReceive, TempWhseShptHeader, TempWhseRcptHeader);    end;    /// <summary>    /// Updates the Gen. Prod. Posting Group on the return receipt line with the value from the item charge.    /// Only lines for item charges that don't have a Gen. Prod. Posting Group are updated.    /// </summary>    /// <param name="ReturnReceiptLine">The return receipt line that is updated.</param>    procedure UpdateChargeItemReturnRcptLineGenProdPostingGroup(var ReturnReceiptLine: Record "Return Receipt Line");    var        ItemCharge: Record "Item Charge";    begin        if not NeedUpdateGenProdPostingGroupOnItemChargeOnReturnRecepitLine(ReturnReceiptLine) then            exit;        ItemCharge.Get(ReturnReceiptLine."No.");        ItemCharge.TestField("Gen. Prod. Posting Group");        ReturnReceiptLine."Gen. Prod. Posting Group" := ItemCharge."Gen. Prod. Posting Group";        ReturnReceiptLine.Modify(false);    end;    /// <summary>    /// Updates the Gen. Prod. Posting Group on the sales shipment line with the value from the item charge.    /// </summary>    /// <param name="SalesShipmentLine">The sales shipment line that is updated.</param>    procedure UpdateChargeItemSalesShptLineGenProdPostingGroup(var SalesShipmentLine: Record "Sales Shipment Line");    var        ItemCharge: Record "Item Charge";    begin        if not NeedUpdateGenProdPostingGroupOnItemChargeOnSalesShipmentLine(SalesShipmentLine) then            exit;        ItemCharge.Get(SalesShipmentLine."No.");        ItemCharge.TestField("Gen. Prod. Posting Group");        SalesShipmentLine."Gen. Prod. Posting Group" := ItemCharge."Gen. Prod. Posting Group";        SalesShipmentLine.Modify(false);    end;    /// <summary>    /// Updates the Gen. Prod. Posting Group on the sales line with the value from the item charge.    /// </summary>    /// <param name="SalesLine">The sales line that is updated.</param>    procedure UpdateChargeItemSalesLineGenProdPostingGroup(var SalesLine: Record "Sales Line");    var        ItemCharge: Record "Item Charge";    begin        if not NeedUpdateGenProdPostingGroupOnItemChargeOnSalesLine(SalesLine) then            exit;        ItemCharge.Get(SalesLine."No.");        ItemCharge.TestField("Gen. Prod. Posting Group");        SalesLine."Gen. Prod. Posting Group" := ItemCharge."Gen. Prod. Posting Group";        SalesLine.Modify(false);    end;    local procedure CreatePrepaymentLineForCreditMemo(var SalesHeader: Record "Sales Header")    var        GLAccount: Record "G/L Account";        SalesLine: Record "Sales Line";        SalesInvoiceLine: Record "Sales Invoice Line";        GeneralPostingSetup: Record "General Posting Setup";        TempPrepmtSalesLine: Record "Sales Line" temporary;        TempExtendedTextLine: Record "Extended Text Line" temporary;        TransferExtendedText: Codeunit "Transfer Extended Text";        LineNo: Integer;        IsHandled: Boolean;    begin        if not CheckApplicationExistForCreditMemo(SalesHeader) then            exit;        SalesLine.SetRange("Document Type", SalesHeader."Document Type");        SalesLine.SetRange("Document No.", SalesHeader."No.");        if SalesLine.FindLast() then            LineNo := SalesLine."Line No." + 10000        else            LineNo := 10000;        TempPrepmtSalesLine.SetHasBeenShown();        SalesInvoiceLine.SetRange("Document No.", SalesHeader."Applies-to Doc. No.");        SalesInvoiceLine.SetRange("Prepayment Line", true);        if SalesInvoiceLine.FindSet() then            repeat                IsHandled := false;                GeneralPostingSetup.Get(SalesInvoiceLine."Gen. Bus. Posting Group", SalesInvoiceLine."Gen. Prod. Posting Group");                OnCreatePrepaymentLineForCreditMemoOnBeforeGetSalesPrepmtAccount(GLAccount, SalesInvoiceLine, IsHandled);                if not IsHandled then                    GLAccount.Get(GeneralPostingSetup.GetSalesPrepmtAccount());                TempPrepmtSalesLine.Init();                TempPrepmtSalesLine."Document Type" := SalesHeader."Document Type";                TempPrepmtSalesLine."Document No." := SalesHeader."No.";                TempPrepmtSalesLine."Line No." := LineNo;                TempPrepmtSalesLine."System-Created Entry" := true;                TempPrepmtSalesLine.Validate(Type, TempPrepmtSalesLine.Type::"G/L Account");                TempPrepmtSalesLine.Validate("No.", GLAccount."No.");                TempPrepmtSalesLine.Validate(Quantity, -1);                TempPrepmtSalesLine.Validate("Qty. to Ship", TempPrepmtSalesLine.Quantity);                TempPrepmtSalesLine.Validate("Qty. to Invoice", TempPrepmtSalesLine.Quantity);                TempPrepmtSalesLine.Validate("Unit Price", SalesInvoiceLine."Unit Price");                TempPrepmtSalesLine.Validate("Prepayment Line", true);                TempPrepmtSalesLine.Validate("Shortcut Dimension 1 Code", SalesInvoiceLine."Shortcut Dimension 1 Code");                TempPrepmtSalesLine.Validate("Shortcut Dimension 2 Code", SalesInvoiceLine."Shortcut Dimension 2 Code");                TempPrepmtSalesLine.Validate("Dimension Set ID", SalesInvoiceLine."Dimension Set ID");                LineNo := LineNo + 10000;                TempPrepmtSalesLine.Insert(true);                TransferExtendedText.PrepmtGetAnyExtText(                    TempPrepmtSalesLine."No.",                    DATABASE::"Sales Cr.Memo Line",                    SalesHeader."Document Date",                    SalesHeader."Language Code",                    TempExtendedTextLine);                if TempExtendedTextLine.FindSet() then                    repeat                        TempPrepmtSalesLine.Init();                        TempPrepmtSalesLine.Validate(Description, TempExtendedTextLine.Text);                        TempPrepmtSalesLine.Validate("System-Created Entry", true);                        TempPrepmtSalesLine.Validate("Prepayment Line", true);                        TempPrepmtSalesLine.Validate("Line No.", LineNo);                        LineNo := LineNo + 10000;                        TempPrepmtSalesLine.Insert(true);                    until TempExtendedTextLine.Next() = 0;            until SalesInvoiceLine.Next() = 0;        if TempPrepmtSalesLine.FindSet() then            repeat                TempSalesLineGlobal := TempPrepmtSalesLine;                TempSalesLineGlobal.Insert(true);            until TempPrepmtSalesLine.Next() = 0;    end;    local procedure CheckApplicationExistForCreditMemo(SalesHeader: Record "Sales Header"): Boolean    begin        if not (SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo") then            exit(false);        if (SalesHeader."Applies-to Doc. Type" <> SalesHeader."Applies-to Doc. Type"::" ") and           (SalesHeader."Applies-to Doc. No." <> '')        then            exit(true);    end;    local procedure AssignPostedDocumentNo(var PostedDocumentNo: Code[20]; DocumentNo: Code[20])    begin        if PreviewMode then            PostedDocumentNo := PostingPreviewNoTok + Format(Random(999999), 0, PostingPreviewNoFormatTxt)        else            PostedDocumentNo := DocumentNo;    end;    local procedure SyncSurPlusItemTracking(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    var        Location2: Record Location;        ReservEntry: Record "Reservation Entry";        TempTrackingSpecification2: Record "Tracking Specification" temporary;        TempWarehouseActivityLine: Record "Warehouse Activity Line" temporary;        WarehouseAvailabilityMgt: Codeunit "Warehouse Availability Mgt.";        QtyReservedForCurrLine: Decimal;        SurplusQtyToHandle: Decimal;        IsHandled: Boolean;    begin        if not SalesHeader.Ship then            exit;        if not (SalesHeader."Document Type" in [SalesHeader."Document Type"::Invoice, SalesHeader."Document Type"::Order]) then            exit;        if (SalesLine."Location Code" = '') or           not Location2.Get(SalesLine."Location Code") or           not Location2."Require Shipment"        then            exit;        TempTrackingSpecification2.SetSourceFromSalesLine(SalesLine);        QtyReservedForCurrLine := Abs(WarehouseAvailabilityMgt.CalcLineReservedQtyOnInvt(            TempTrackingSpecification2."Source Type", TempTrackingSpecification2."Source Subtype", TempTrackingSpecification2."Source ID", TempTrackingSpecification2."Source Ref. No.",            0, false, TempWarehouseActivityLine));        if QtyReservedForCurrLine = 0 then            exit;        ReservEntry.SetSourceFilter(                                 TempTrackingSpecification2."Source Type", TempTrackingSpecification2."Source Subtype",                                 TempTrackingSpecification2."Source ID", TempTrackingSpecification2."Source Ref. No.", true);        ReservEntry.SetSourceFilter('', TempTrackingSpecification2."Source Prod. Order Line");        ReservEntry.SetRange("Reservation Status", ReservEntry."Reservation Status"::Surplus);        if not ReservEntry.FindSet() then            exit;        ReservEntry.CalcSums("Qty. to Handle (Base)");        SurplusQtyToHandle := Abs(ReservEntry."Qty. to Handle (Base)");        if (QtyReservedForCurrLine + SurplusQtyToHandle) <= SalesLine."Qty. to Ship (Base)" then            exit;        IsHandled := false;        OnSyncSurPlusItemTrackingOnBeforeModifyQtyToHandleInvoice(SalesLine, SalesHeader, IsHandled, ReservEntry);        if IsHandled then            exit;        ReservEntry.ModifyAll("Qty. to Handle (Base)", 0);        ReservEntry.ModifyAll("Qty. to Invoice (Base)", 0);    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Item Jnl.-Post Line", 'OnBeforePostValueEntryToGL', '', false, false)]    local procedure OnBeforePostValueEntryToGL(var ValueEntry: Record "Value Entry"; var IsHandled: Boolean; PostToGL: Boolean)    var        InventorySetup: Record "Inventory Setup";    begin        if not PostToGL then            exit;        if InventorySetup.UseLegacyPosting() then            exit;        PostponedValueEntries.Add(ValueEntry."Entry No.");        IsHandled := true;    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;    /// <summary>    /// Raised before modifying the purchase order line during archive purchase orders.    /// </summary>    /// <param name="PurchOrderLine">The purchase order line.</param>    /// <param name="TempDropShptPostBuffer">The temporary drop shipment post buffer.</param>    [IntegrationEvent(false, false)]    local procedure OnArchivePurchaseOrdersOnBeforePurchOrderLineModify(var PurchOrderLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    /// <summary>    /// Raised before posting the item journal line before post.    /// </summary>    /// <param name="SalesLine">The sales line being processed.</param>    /// <param name="ItemJnlLine">The item journal line.</param>    /// <param name="TempWhseJnlLine">The temporary warehouse journal line.</param>    /// <param name="Location">The location record.</param>    /// <param name="PostWhseJnlLine">Indicates whether to post warehouse journal line.</param>    /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="TrackingSpecification">The tracking specification.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemJnlLineBeforePost(SalesLine: Record "Sales Line"; var ItemJnlLine: Record "Item Journal Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; Location: Record Location; var PostWhseJnlLine: Boolean; QtyToBeShippedBase: Decimal; var IsHandled: Boolean; TrackingSpecification: Record "Tracking Specification")    begin    end;    /// <summary>    /// Raised before deleting the sales document after posting.    /// </summary>    /// <param name="SalesHeader">The sales header to delete.</param>    /// <param name="SalesInvoiceHeader">The posted sales invoice header.</param>    /// <param name="SalesCrMemoHeader">The posted sales credit memo header.</param>    /// <param name="SkipDelete">Set to true to skip the delete operation.</param>    /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param>    /// <param name="EverythingInvoiced">Indicates whether everything has been invoiced.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteAfterPosting(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var SkipDelete: Boolean; CommitIsSuppressed: Boolean; EverythingInvoiced: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary)    begin    end;    /// <summary>    /// Raised before deleting approval entries.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="IsHandled">Set to true to skip the default delete logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteApprovalEntries(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before finding the customer ledger entry.    /// </summary>    /// <param name="CustLedgEntry">The customer ledger entry to find.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeFindCustLedgEntry(var CustLedgEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Raised before getting the country code.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="CountryRegionCode">The country/region code to return.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetCountryCode(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var CountryRegionCode: Code[10]; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before getting the country/region code.    /// </summary>    /// <param name="CustNo">The customer number.</param>    /// <param name="ShipToCode">The ship-to code.</param>    /// <param name="SellToCountryRegionCode">The sell-to country/region code.</param>    /// <param name="Result">The result country/region code.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetCountryRegionCode(CustNo: Code[20]; ShipToCode: Code[10]; SellToCountryRegionCode: Code[10]; var Result: Code[10]; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before getting the item entry relation.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="ItemEntryRelation">The item entry relation.</param>    /// <param name="TempTrackingSpecification">The temporary tracking specification.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetItemEntryRelation(var SalesHeader: Record "Sales Header"; var ItemEntryRelation: Record "Item Entry Relation"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before getting the sales line quantity.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="QtyType">The quantity type (General, Invoicing, or Shipping).</param>    /// <param name="SalesLineQty">The sales line quantity to return.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetSalesLineQty(SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; var SalesLineQty: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before getting return receipt line from tracking or updating item entry relation.    /// </summary>    /// <param name="TempTrackingSpecification">The temporary tracking specification.</param>    /// <param name="ReturnRcptLine">The return receipt line.</param>    /// <param name="ItemEntryRelation">The item entry relation.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetReturnRcptLineFromTrackingOrUpdateItemEntryRelation(var TempTrackingSpecification: Record "Tracking Specification" temporary; var ReturnRcptLine: Record "Return Receipt Line"; var ItemEntryRelation: Record "Item Entry Relation"; var IsHandled: Boolean; TrackingSpecificationExists: Boolean)    begin    end;    /// <summary>    /// Raised before initializing sales line quantity to invoice.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesLine">The sales line to initialize.</param>    /// <param name="IsHandled">Set to true to skip the default initialization logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInitSalesLineQtyToInvoice(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before initializing post assemble-to-order.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="AsmPost">The assembly post codeunit instance.</param>    /// <param name="HideProgressWindow">Indicates whether to hide the progress window.</param>    /// <param name="IsHandled">Set to true to skip the default initialization logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInitPostATO(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var AsmPost: Codeunit "Assembly-Post"; HideProgressWindow: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before inserting the return receipt line.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="ReturnRcptLine">The return receipt line to insert.</param>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    /// <param name="RemQtyToBeInvoicedBase">The remaining quantity to be invoiced in base unit of measure.</param>    /// <param name="IsHandled">Set to true to skip the default insert logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertReturnReceiptLine(SalesLine: Record "Sales Line"; ReturnRcptLine: Record "Return Receipt Line"; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before posting ATO associated item journal line.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="PostedATOLink">The posted assemble-to-order link.</param>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    /// <param name="RemQtyToBeInvoicedBase">The remaining quantity to be invoiced in base unit of measure.</param>    /// <param name="ItemLedgShptEntryNo">The item ledger shipment entry number.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostATOAssocItemJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var PostedATOLink: Record "Posted Assemble-to-Order Link"; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; var ItemLedgShptEntryNo: Integer; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before evaluating the condition for posting item tracking for receipt.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="ReturnRcptLine">The return receipt line.</param>    /// <param name="Condition">The condition result.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingForReceiptCondition(SalesLine: Record "Sales Line"; ReturnRcptLine: Record "Return Receipt Line"; var Condition: Boolean)    begin    end;    /// <summary>    /// Raised before evaluating the condition for posting item tracking for shipment.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="SalesShptLine">The sales shipment line.</param>    /// <param name="Condition">The condition result.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingForShipmentCondition(SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; var Condition: Boolean)    begin    end;    /// <summary>    /// Raised before posting the item tracking line.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="TempItemLedgEntryNotInvoiced">The temporary item ledger entries not invoiced.</param>    /// <param name="HasATOShippedNotInvoiced">Indicates whether ATO has been shipped but not invoiced.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="ItemLedgShptEntryNo">The item ledger shipment entry number.</param>    /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param>    /// <param name="RemQtyToBeInvoicedBase">The remaining quantity to be invoiced in base unit of measure.</param>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforePostItemTrackingLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean; var IsHandled: Boolean; var ItemLedgShptEntryNo: Integer; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; SalesInvoiceHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header")    begin    end;    /// <summary>    /// Raised before posting the sales lines.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param>    /// <param name="TempVATAmountLine">The temporary VAT amount line.</param>    /// <param name="EverythingInvoiced">Indicates whether everything has been invoiced.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostSalesLines(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var TempVATAmountLine: Record "VAT Amount Line" temporary; var EverythingInvoiced: Boolean)    begin    end;    /// <summary>    /// Raised before setting the item entry relation.    /// </summary>    /// <param name="ItemEntryRelation">The item entry relation to set.</param>    /// <param name="SalesShptLine">The sales shipment line.</param>    /// <param name="InvoicingTrackingSpecification">The invoicing tracking specification.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSetItemEntryRelation(var ItemEntryRelation: Record "Item Entry Relation"; var SalesShptLine: Record "Sales Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before determining if warehouse journal line should be posted.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="Result">The result of the determination.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeShouldPostWhseJnlLine(SalesLine: Record "Sales Line"; var Result: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before summing sales lines (variant 2).    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="NewSalesLine">The new sales line for totals.</param>    /// <param name="OldSalesLine">The old sales line being processed.</param>    /// <param name="QtyType">The quantity type (General, Invoicing, or Shipping).</param>    /// <param name="InsertSalesLine">Indicates whether to insert the sales line.</param>    /// <param name="CalcAdCostLCY">Indicates whether to calculate adjusted cost in LCY.</param>    /// <param name="TotalAdjCostLCY">The total adjusted cost in LCY.</param>    /// <param name="IncludePrepayments">Indicates whether to include prepayments.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSumSalesLines2(SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; InsertSalesLine: Boolean; CalcAdCostLCY: Boolean; var TotalAdjCostLCY: Decimal; IncludePrepayments: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before summing temporary sales lines.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="OldSalesLine">The old sales line.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSumSalesLinesTemp(var SalesHeader: Record "Sales Header"; var OldSalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised before posting warehouse shipment lines.    /// </summary>    /// <param name="WhseShptLine2">The warehouse shipment line.</param>    /// <param name="SalesShptLine2">The sales shipment line.</param>    /// <param name="SalesLine2">The sales line.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="PostedWhseShptHeader">The posted warehouse shipment header.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostWhseShptLines(var WhseShptLine2: Record "Warehouse Shipment Line"; SalesShptLine2: Record "Sales Shipment Line"; var SalesLine2: Record "Sales Line"; var IsHandled: Boolean; PostedWhseShptHeader: Record "Posted Whse. Shipment Header")    begin    end;    /// <summary>    /// Raised when setting filters for calculating invoice discount.    /// </summary>    /// <param name="SalesLine">The sales line to set filters on.</param>    /// <param name="SalesHeader">The sales header.</param>    [IntegrationEvent(false, false)]    local procedure OnCalcInvDiscountSetFilter(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after setting factor during calculation of item journal amounts from quantity to be invoiced.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="Factor">The calculated factor.</param>    /// <param name="ItemJournalLine">The item journal line.</param>    [IntegrationEvent(false, false)]    local procedure OnCalcItemJnlAmountsFromQtyToBeInvoicedOnAfterSetFactor(SalesLine: Record "Sales Line"; var Factor: Decimal; var ItemJournalLine: Record "Item Journal Line")    begin    end;    /// <summary>    /// Raised after processing sales lines during create prepayment lines.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="TempPrepmtSalesLine">The temporary prepayment sales line.</param>    /// <param name="NextLineNo">The next line number.</param>    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnAfterProcessSalesLines(SalesHeader: Record "Sales Header"; var TempPrepmtSalesLine: Record "Sales Line" temporary; var NextLineNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineModify(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineInsert(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before inserting temporary line for extended text during create prepayment lines.    /// </summary>    /// <param name="TempPrepmtSalesLine">The temporary prepayment sales line.</param>    /// <param name="TempSalesLine">The temporary sales line.</param>    /// <param name="TempExtTextLine">The temporary extended text line.</param>    /// <param name="SalesHeader">The sales header.</param>    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnBeforeInsertTempLineForExtText(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; var TempExtTextLine: Record "Extended Text Line" temporary; var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before filling temporary lines in the main code procedure.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="CalledBy">Identifies the caller of the posting routine.</param>    [IntegrationEvent(false, false)]    local procedure OnCodeOnBeforeFillTempLines(var SalesHeader: Record "Sales Header"; CalledBy: Integer)    begin    end;    /// <summary>    /// Raised before loop during copy and check item charge.    /// </summary>    /// <param name="TempSalesLine">The temporary sales line.</param>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SkipTestJobNo">Set to true to skip the job number test.</param>    [IntegrationEvent(false, false)]    local procedure OnCopyAndCheckItemChargeOnBeforeLoop(var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; var SkipTestJobNo: Boolean)    begin    end;    /// <summary>    /// Raised after setting filters during copy to temporary lines.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="SalesHeader">The sales header.</param>    [IntegrationEvent(false, false)]    local procedure OnCopyToTempLinesOnAfterSetFilters(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised before inserting new item charge assignment during insert associated order charge.    /// </summary>    /// <param name="TempItemChargeAssgntSales">The temporary item charge assignment.</param>    /// <param name="NewItemChargeAssgntSales">The new item charge assignment to insert.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertAssocOrderChargeOnBeforeNewItemChargeAssgntSalesInsert(TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)"; var NewItemChargeAssgntSales: Record "Item Charge Assignment (Sales)")    begin    end;    /// <summary>    /// Raised after transferring fields to sales credit memo header during insert credit memo header.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesCrMemoHeader">The sales credit memo header.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertCrMemoHeaderOnAfterSalesCrMemoHeaderTransferFields(var SalesHeader: Record "Sales Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header")    begin    end;    /// <summary>    /// Raised before transferring fields to sales credit memo header during insert credit memo header.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertCrMemoHeaderOnBeforeSalesCrMemoHeaderTransferFields(var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after calculating whether to insert shipment header during insert posted headers.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="TempWarehouseShipmentHeader">The temporary warehouse shipment header.</param>    /// <param name="TempWarehouseReceiptHeader">The temporary warehouse receipt header.</param>    /// <param name="InsertShipmentHeaderNeeded">Indicates whether inserting shipment header is needed.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertPostedHeadersOnAfterCalcInsertShipmentHeaderNeeded(var SalesHeader: Record "Sales Header"; var TempWarehouseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary; var InsertShipmentHeaderNeeded: Boolean)    begin    end;    /// <summary>    /// Raised before inserting the invoice header during insert posted headers.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="IsHandled">Set to true to skip the default insert logic.</param>    /// <param name="SalesInvHeader">The sales invoice header.</param>    /// <param name="GenJnlLineDocType">The general journal line document type.</param>    /// <param name="GenJnlLineDocNo">The general journal line document number.</param>    /// <param name="GenJnlLineExtDocNo">The general journal line external document number.</param>    /// <param name="InvoicePostingInterface">The invoice posting interface.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertPostedHeadersOnBeforeInsertInvoiceHeader(SalesHeader: Record "Sales Header"; var IsHandled: Boolean; SalesInvHeader: Record "Sales Invoice Header"; var GenJnlLineDocType: Enum "Gen. Journal Document Type"; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35]; var InvoicePostingInterface: Interface "Invoice Posting")    begin    end;    /// <summary>    /// Raised before creating posted receipt line during insert return receipt line.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="ReturnRcptLine">The return receipt line.</param>    /// <param name="WhseRcptLine">The warehouse receipt line.</param>    /// <param name="PostedWhseRcptHeader">The posted warehouse receipt header.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertReturnReceiptLineOnBeforeCreatePostedRcptLine(SalesLine: record "Sales Line"; var ReturnRcptLine: record "Return Receipt Line"; var WhseRcptLine: Record "Warehouse Receipt Line"; PostedWhseRcptHeader: Record "Posted Whse. Receipt Header")    begin    end;    /// <summary>    /// Raised after calculating whether to get warehouse receipt line during insert return receipt line warehouse post.    /// </summary>    /// <param name="ReturnRcptLine">The return receipt line.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="ReturnRcptHeader">The return receipt header.</param>    /// <param name="ShouldGetWhseRcptLine">Indicates whether to get warehouse receipt line.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertReturnReceiptLineWhsePostOnAfterCalcShouldGetWhseRcptLine(var ReturnRcptLine: Record "Return Receipt Line"; SalesLine: Record "Sales line"; WhseShip: Boolean; WhseReceive: Boolean; ReturnRcptHeader: Record "Return Receipt Header"; var ShouldGetWhseRcptLine: Boolean)    begin    end;    /// <summary>    /// Raised after calculating whether to get warehouse shipment line during insert return receipt line warehouse post.    /// </summary>    /// <param name="ReturnRcptLine">The return receipt line.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param>    /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param>    /// <param name="ReturnRcptHeader">The return receipt header.</param>    /// <param name="ShouldGetWhseShptLine">Indicates whether to get warehouse shipment line.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertReturnReceiptLineWhsePostOnAfterCalcShouldGetWhseShptLine(var ReturnRcptLine: Record "Return Receipt Line"; SalesLine: Record "Sales line"; WhseShip: Boolean; WhseReceive: Boolean; ReturnRcptHeader: Record "Return Receipt Header"; var ShouldGetWhseShptLine: Boolean)    begin    end;    /// <summary>    /// Raised before creating posted shipment line during insert return receipt line warehouse post.    /// </summary>    /// <param name="ReturnRcptLine">The return receipt line.</param>    /// <param name="WhseShptLine">The warehouse shipment line.</param>    /// <param name="PostedWhseShptHeader">The posted warehouse shipment header.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertReturnReceiptLineWhsePostOnBeforeCreatePostedShptLine(var ReturnRcptLine: Record "Return Receipt Line"; var WhseShptLine: Record "Warehouse Shipment Line"; PostedWhseShptHeader: Record "Posted Whse. Shipment Header")    begin    end;    /// <summary>    /// Raised after transferring fields to sales shipment header during insert shipment header.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesShptHeader">The sales shipment header.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertShipmentHeaderOnAfterTransferfieldsToSalesShptHeader(SalesHeader: Record "Sales Header"; var SalesShptHeader: Record "Sales Shipment Header")    begin    end;    /// <summary>    /// Raised before transferring fields to sales shipment header during insert shipment header.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertShipmentHeaderOnBeforeTransferfieldsToSalesShptHeader(var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after initializing quantity fields during insert shipment line.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="xSalesLine">The previous sales line.</param>    /// <param name="SalesShptLine">The sales shipment line.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertShipmentLineOnAfterInitQuantityFields(var SalesLine: Record "Sales Line"; var xSalesLine: Record "Sales Line"; var SalesShptLine: Record "Sales Shipment Line")    begin    end;    /// <summary>    /// Raised after calculating whether to process shipment relation during insert shipment line.    /// </summary>    /// <param name="SalesLine">The sales line.</param>    /// <param name="ShouldProcessShipmentRelation">Indicates whether to process shipment relation.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertShipmentLineOnAfterCalcShouldProcessShipmentRelation(var SalesLine: Record "Sales Line"; var ShouldProcessShipmentRelation: Boolean)    begin    end;    /// <summary>    /// Raised before transferring fields to sales invoice header during insert invoice header.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertInvoiceHeaderOnBeforeSalesInvHeaderTransferFields(var SalesHeader: Record "Sales Header")    begin    end;    /// <summary>    /// Raised after transferring fields to sales invoice header during insert invoice header.    /// </summary>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesInvoiceHeader">The sales invoice header.</param>    [IntegrationEvent(false, false)]    local procedure OnInsertInvoiceHeaderOnAfterSalesInvHeaderTransferFields(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header")    begin    end;    /// <summary>    /// Raised before dividing amount during sum sales lines 2.    /// </summary>    /// <param name="OldSalesLine">The old sales line.</param>    /// <param name="IsHandled">Set to true to skip the default logic.</param>    /// <param name="SalesHeader">The sales header.</param>    /// <param name="SalesLine">The sales line.</param>    /// <param name="QtyType">The quantity type.</param>    /// <param name="SalesLineQty">The sales line quantity.</param>    /// <param name="TempVATAmountLine">The temporary VAT amount line.</param>    /// <param name="TempVATAmountLineRemainder">The temporary VAT amount line remainder.</param>    /// <param name="IncludePrepayments">Indicates whether to include prepayments.</param>    /// <param name="RoundingLineInserted">Indicates whether a rounding line was inserted.</param>    [IntegrationEvent(false, false)]    local procedure OnSumSalesLines2OnBeforeDivideAmount(var OldSalesLine: Record "Sales Line"; var IsHandled: Boolean; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyType: Option; var SalesLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; IncludePrepayments: Boolean; RoundingLineInserted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSumSalesLines2OnAfterDivideAmount(var OldSalesLine: Record "Sales Line"; var SalesLineQty: Decimal; QtyType: Option General,Invoicing,Shipping)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSumSalesLines2OnAfterCalcTotalAdjCostLCY(var TotalAdjCostLCY: decimal; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSumSalesLines2OnBeforeCalcVATAmountLines(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; InsertSalesLine: Boolean; var TempVATAmountLine: Record "VAT Amount Line" temporary; QtyType: Option General,Invoicing,Shipping; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSumSalesLines2OnBeforeNewSalesLineInsert(var NewSalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSumSalesLines2SetFilter(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; InsertSalesLine: Boolean; var QtyType: Option)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineWhseLineOnBeforePostTempWhseJnlLine2(var TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary; WhseShip: Boolean; WhseReceive: Boolean; InvtPickPutaway: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnAfterTestUpdatedSalesLine(var SalesLine: Record "Sales Line"; var EverythingInvoiced: Boolean; SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineBeforeInitQtyToInvoice(var TempSalesLine: Record "Sales Line" temporary; WhseShip: Boolean; WhseReceive: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeInitOutstanding(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeInitTempSalesLineQuantities(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnAfterUpdateInvoicedValues(var TempSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnAfterModifySalesOrderLine(var SalesOrderLine: Record "Sales Line"; TempSalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnBeforeModifySalesOrderLine(var SalesOrderLine: Record "Sales Line"; TempSalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnAfterInsertSalesOrderHeader(var SalesOrderLine: Record "Sales Line"; TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnAfterInitQtyToReceiveOrShip(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; WhseShip: Boolean; WhseReceive: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeUpdateInvoicedValues(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostUpdateOrderLineOnSetDefaultQtyBlank(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; SalesSetup: Record "Sales & Receivables Setup"; var SetDefaultQtyBlank: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcInvoiceOnAfterTempSalesLineSetFilters(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCheckAndUpdateOnAfterCalcInvDiscount(SalesHeader: Record "Sales Header"; TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; PreviewMode: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary; SuppressCommit: Boolean; WhseReceive: Boolean; WhseShip: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnAfterReleaseSalesDocument(SalesHeader: Record "Sales Header"; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCheckAndUpdateOnBeforeSetPostingFlags(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var ModifyHeader: Boolean; var HideProgressWindow: Boolean);    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCheckAndUpdateOnAfterSetPostingFlags(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var ModifyHeader: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnAfterSetSourceCode(var SalesHeader: Record "Sales Header"; SourceCodeSetup: Record "Source Code Setup"; var SrcCode: Code[10]);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnAfterSetPoszingFromWhseRef(var SalesHeader: Record "Sales Header"; var InvtPickPutaway: Boolean; var PostingFromWhseRef: Integer);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnBeforeCalcInvDiscount(var SalesHeader: Record "Sales Header"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; WhseReceive: Boolean; WhseShip: Boolean; var RefreshNeeded: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnBeforeCheckPostRestrictions(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAssosOrderLinesOnAfterSetFilters(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCheckSalesDocumentOnAfterCalcShouldCheckItemCharge(var SalesHeader: Record "Sales Header"; WhseReceive: Boolean; WhseShip: Boolean; var ShouldCheckItemCharge: Boolean; var ModifyHeader: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckTrackingAndWarehouseForShipOnBeforeCheck(var SalesHeader: Record "Sales Header"; var TempWhseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWhseReceiptHeader: Record "Warehouse Receipt Header" temporary; var Ship: Boolean; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCheckTrackingAndWarehouseForReceiveOnBeforeCheck(var SalesHeader: Record "Sales Header"; var TempWhseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWhseReceiptHeader: Record "Warehouse Receipt Header" temporary; var Receive: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckTrackingSpecificationOnAfterTempItemSalesLineLoop(var TempItemSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckCustBlockageOnAfterTempLinesSetFilters(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineSetFilters(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnAfterGetSalesPrepmtAccount(var GLAcc: Record "G/L Account"; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnBeforeGetSalesPrepmtAccount(var GLAcc: Record "G/L Account"; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; var GenPostingSetup: Record "General Posting Setup"; CompleteFunctionality: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnAfterTempSalesLineSetFilters(var TempSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var TempPrepmtSalesLine: Record "Sales Line" temporary; var NextLineNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnFinalizePostingOnAfterUpdateItemChargeAssgnt(var SalesHeader: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnFinalizePostingOnBeforeInsertTrackingSpecification(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; SalesHeader: Record "Sales Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary; EverythingInvoiced: Boolean; var TempSalesLine: Record "Sales Line" temporary; var TempSalesLineGlobal: Record "Sales Line" temporary; SalesPost: Codeunit "Sales-Post")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnFinalizePostingOnBeforeCreateOutboxSalesTrans(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; EverythingInvoiced: Boolean; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnFinalizePostingOnBeforeDeleteApprovalEntries(var SalesHeader: Record "Sales Header"; var EverythingInvoiced: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnFinalizePostingOnBeforeGenJnlPostPreviewThrowError(SalesHeader: Record "Sales Header"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostAssocItemJnlLineOnBeforePost(var ItemJournalLine: Record "Item Journal Line"; PurchOrderLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostATOOnBeforePostedATOLinkInsert(var PostedATOLink: Record "Posted Assemble-to-Order Link"; var AssemblyHeader: Record "Assembly Header"; var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostATOAssocItemJnlLineOnBeforeRemainingPost(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var PostedATOLink: Record "Posted Assemble-to-Order Link"; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; var ItemLedgShptEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDropOrderShipmentOnAfterUpdateBlanketOrderLine(PurchOrderHeader: Record "Purchase Header"; PurchOrderLine: Record "Purchase Line"; TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; SalesShptHeader: Record "Sales Shipment Header"; SalesHeader: Record "Sales Header"; PurchRcptHeader: Record "Purch. Rcpt. Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary; SrcCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterCopyDocumentFields(var ItemJournalLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterCalcShouldPostItemJnlLineItemCharges(SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; var ShouldPostItemJnlLineItemCharges: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterPrepareItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; WhseShip: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var QtyToBeShipped: Decimal; TrackingSpecification: Record "Tracking Specification"; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; var QtyToBeShippedBase: Decimal; var RemAmt: Decimal; var RemDiscAmt: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterCopyItemCharge(var ItemJournalLine: Record "Item Journal Line"; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnBeforeIsJobContactLineCheck(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var ShouldPostItemJnlLine: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; QtyToBeShipped: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterItemJnlPostLineRunWithCheck(var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnBeforePostItemJnlLineWhseLine(var ItemJnlLine: Record "Item Journal Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnBeforeTransferReservToItemJnlLine(SalesLine: Record "Sales Line"; ItemJnlLine: Record "Item Journal Line"; var CheckApplFromItemEntry: Boolean; var TrackingSpecification: Record "Tracking Specification"; QtyToBeShippedBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnBeforeCopyTrackingFromSpec(TrackingSpecification: Record "Tracking Specification"; var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; IsATO: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineItemChargesOnAfterGetItemChargeLine(var ItemChargeSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLinePrepareJournalLineOnBeforeCalcItemJnlAmounts(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; IsATO: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargeOnBeforePostItemJnlLine(var SalesLineToPost: Record "Sales Line"; var SalesLine: Record "Sales Line"; QtyToAssign: Decimal; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerOrderOnAfterCopyToItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var SalesLine: Record "Sales Line"; GeneralLedgerSetup: Record "General Ledger Setup"; QtyToInvoice: Decimal; var TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerOrderOnAfterTempTrackingSpecificationInvSetFilters(SalesHeader: record "Sales Header"; var ItemJnlLine2: record "Item Journal Line"; var TempTrackingSpecificationInv: Record "Tracking Specification" temporary; SalesLine: Record "Sales Line"; var IsHandled: Boolean; var TotalSalesLineLCY: Record "Sales Line"; var TotalSalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerOrderOnBeforeTestJobNo(SalesLine: Record "Sales Line"; var SkipTestJobNo: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerOrderOnBeforeLastRunWithCheck(NonDistrItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerOrderOnBeforeRunWithCheck(ItemJnlLine2: Record "Item Journal Line"; var IsHandled: Boolean; var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerShptOnBeforeTestJobNo(SalesShipmentLine: Record "Sales Shipment Line"; var SkipTestJobNo: Boolean; var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerShptOnAfterCheckItemChargePerShpt(SalesShipmentLine: Record "Sales Shipment Line"; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; DistributeCharge: Boolean; var IsHandled: Boolean; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerShptOnAfterCalcDistributeCharge(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; TempItemLedgEntry: Record "Item Ledger Entry" temporary; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; var DistributeCharge: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerRetRcptOnAfterCalcDistributeCharge(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; ReturnRcptLine: Record "Return Receipt Line"; TempItemLedgEntry: Record "Item Ledger Entry" temporary; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; var DistributeCharge: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerRetRcptOnBeforeTestFieldJobNo(ReturnReceiptLine: Record "Return Receipt Line"; var IsHandled: Boolean; var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingLineOnAfterRetrieveInvoiceSpecification(var SalesLine: Record "Sales Line"; var TempInvoicingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForShipmentOnAfterSetFilters(var SalesShipmentLine: Record "Sales Shipment Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForShipmentOnAfterUpdateSalesShptLineFields(var SalesShipmentLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForShipmentOnBeforeAdjustQuantityRounding(SalesShptLine: Record "Sales Shipment Line"; RemQtyToInvoiceCurrLine: Decimal; var QtyToBeInvoiced: Decimal; RemQtyToInvoiceCurrLineBase: Decimal; QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; HasATOShippedNotInvoiced: Boolean; var ShouldAdjustQuantityRounding: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostItemTrackingForShipmentOnBeforeShipmentInvoiceErr(SalesLine: Record "Sales Line"; var IsHandled: Boolean; SalesHeader: Record "Sales Header"; var ItemJnlRollRndg: Boolean; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostItemTrackingForShipmentOnBeforeReturnReceiptInvoiceErr(SalesLine: Record "Sales Line"; var IsHandled: Boolean; SalesHeader: Record "Sales Header"; var ItemJnlRollRndg: Boolean; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForReceiptOnAfterSetFilters(var ReturnReceiptLine: Record "Return Receipt Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnBeforeInsertCrMemoLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean; xSalesLine: Record "Sales Line"; SalesCrMemoHeader: Record "Sales Cr.Memo Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnBeforeInsertInvoiceLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean; xSalesLine: Record "Sales Line"; SalesInvHeader: Record "Sales Invoice Header"; var ShouldInsertInvoiceLine: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnBeforeInsertReturnReceiptLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnBeforeInsertShipmentLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean; SalesLineACY: Record "Sales Line"; DocType: Option; DocNo: Code[20]; ExtDocNo: Code[35])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnAfterSetEverythingInvoiced(SalesLine: Record "Sales Line"; var EverythingInvoiced: Boolean; var IsHandled: Boolean; SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnAfterRoundAmount(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; GenJnlLineDocNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnBeforeTestJobNo(SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostSalesLineOnAfterPostItemTrackingLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; WhseShip: Boolean; WhseReceive: Boolean; InvtPickPutaway: Boolean; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnAfterTestSalesLine(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header"; var WhseShptHeader: Record "Warehouse Shipment Header"; WhseShip: Boolean; PreviewMode: Boolean; var CostBaseAmount: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostSalesLineOnBeforePostItemTrackingLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; WhseShip: Boolean; WhseReceive: Boolean; InvtPickPutaway: Boolean; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ItemLedgShptEntryNo: Integer; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; GenJnlLineDocNo: Code[20]; SrcCode: Code[10]; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnBeforeTestUnitOfMeasureCode(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnAfterAdjustPrepmtAmountLCY(var SalesLine: record "Sales Line"; var xSalesLine: record "Sales Line"; TempTrackingSpecification: record "Tracking Specification" temporary; SalesHeader: record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnAfterInsertReturnReceiptLine(var SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var xSalesLine: Record "Sales Line"; ReturnRcptHeader: Record "Return Receipt Header"; RoundingLineInserted: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var ItemLedgShptEntryNo: Integer; SalesShipmentHeader: Record "Sales Shipment Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnAfterGetSalesOrderLine(var TempSalesLine: Record "Sales Line" temporary; SalesShptLine: Record "Sales Shipment Line"; SalesOrderLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnBeforeInitQtyToInvoice(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnBeforeCalcQuantityInvoiced(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateReturnReceiptLineOnAfterGetSalesOrderLine(var TempSalesLine: Record "Sales Line" temporary; ReturnRcptLine: Record "Return Receipt Line"; SalesOrderLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateReturnReceiptLineOnBeforeInitQtyToInvoice(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateReturnReceiptLineOnAfterModifySalesOrderLine(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateReturnReceiptLineOnBeforeModifySalesOrderLine(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateReturnReceiptLineOnBeforeCalcQuantityInvoiced(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnProcessAssocItemJnlLineOnBeforeTempDropShptPostBufferInsert(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnProcessAssocItemJnlLineOnBeforePostAssocItemJnlLine(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRoundAmountOnBeforeIncrAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal; var TotalSalesLine: Record "Sales Line"; var TotalSalesLineLCY: Record "Sales Line"; var xSalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforeCheckTotalInvoiceAmount(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforeFinalizePosting(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptHeader: Record "Return Receipt Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; CommitIsSuppressed: Boolean; GenJnlLineExtDocNo: Code[35]; var EverythingInvoiced: Boolean; GenJnlLineDocNo: Code[20]; SrcCode: Code[10]; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforePostSalesLineEndLoop(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var LastLineRetrieved: Boolean; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; RecSalesHeader: Record "Sales Header"; xSalesLine: Record "Sales Line"; var SalesShipmentHeader: Record "Sales Shipment Header"; var ReturnReceiptHeader: Record "Return Receipt Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetATOItemLedgEntriesNotInvoicedOnBeforeItemLedgEntryNotInvoicedInsert(var ItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetPostedDocumentRecordElseCase(SalesHeader: Record "Sales Header"; var PostedSalesDocumentVariant: Variant; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetSalesLinesOnAfterFillTempLines(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemLineOnAfterMakeSalesLineToShip(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemLineOnBeforeMakeSalesLineToShip(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary; var ItemLedgShptEntryNo: Integer; var IsHandled: Boolean; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35]; ReturnReceiptHeader: Record "Return Receipt Header"; var TempHandlingSpecification: Record "Tracking Specification" temporary; var TempHandlingSpecificationInv: Record "Tracking Specification" temporary; var TempTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemLineOnBeforePostItemInvoiceLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargeOnAfterPostItemJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostItemChargeLineOnAfterTempItemChargeAssgntSalesLoop(var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineParam: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargeLineOnBeforePostItemCharge(var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForReceiptOnBeforeReturnRcptLineModify(SalesHeader: Record "Sales Header"; var ReturnRcptLine: Record "Return Receipt Line"; SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForReceiptOnBeforeAdjustQuantityRounding(ReturnRcptLine: Record "Return Receipt Line"; RemQtyToInvoiceCurrLine: Decimal; var QtyToBeInvoiced: Decimal; RemQtyToInvoiceCurrLineBase: Decimal; QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; var ShouldAdjustQuantityRounding: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnReleaseSalesDocumentOnBeforeSetStatus(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; SavedStatus: Enum "Sales Document Status"; PreviewMode: Boolean; SuppressCommit: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRoundAmountOnAfterAssignSalesLines(var xSalesLine: Record "Sales Line"; var SalesLineACY: Record "Sales Line"; SalesHeader: Record "Sales Header"; var IsHandled: Boolean; var TotalSalesLines: Record "Sales Line"; var TotalSalesLineLCY: Record "Sales Line"; var SalesLine: Record "Sales Line");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSaveInvoiceSpecificationOnAfterUpdateTempTrackingSpecification(var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempInvoicingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSaveInvoiceSpecificationOnBeforeAssignTempInvoicingSpecification(var TempInvoicingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSendICDocumentOnBeforeSetICStatus(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSendPostedDocumentRecordElseCase(SalesHeader: Record "Sales Header"; var DocumentSendingProfile: Record "Document Sending Profile"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnTestSalesLineOnAfterTestSalesLineJob(var SalesLine: record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnTestSalesLineOnAfterCalcShouldTestReturnQty(SalesLine: Record "Sales Line"; var ShouldTestReturnQty: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTestGenPostingGroups(var SalesLine: record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateSalesLineBeforePostOnAfterPostJobContractLine(SalesInvoiceHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssosOrderOnAfterPurchOrderHeaderModify(var PurchOrderHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssocOrderOnAfterModifyPurchLine(var PurchOrderLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssocOrderOnBeforeModifyPurchLine(var PurchOrderLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssosOrderPostingNosOnAfterReleasePurchaseDocument(var PurchOrderHeader: Record "Purchase Header"; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssosOrderPostingNosOnBeforeReleasePurchaseDocument(var PurchOrderHeader: Record "Purchase Header"; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAfterPostingOnBeforeFindSetForUpdate(var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateBlanketOrderLineOnBeforeCheck(var BlanketOrderSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateBlanketOrderLineOnBeforeCheckSellToCustomerNo(var BlanketOrderSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateBlanketOrderLineOnBeforeInitOutstanding(var BlanketOrderSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateInvoicedQtyOnShipmentLineOnBeforeModifySalesShptLine(var SalesShptLine: Record "Sales Shipment Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnAfterInitAmount(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnAfterInitLineDiscountAmount(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnBeforeTempVATAmountLineRemainderModify(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; Currency: Record Currency)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcVATBaseAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; Currency: Record Currency; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostUpdateInvoiceLine(var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostUpdateReturnReceiptLine(var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertTrackingSpecification(SalesHeader: Record "Sales Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSendPostedDocumentRecord(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; var DocumentSendingProfile: Record "Document Sending Profile")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemChargeLine(var SalesLine: Record "Sales Line"; SalesLineACY: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDeleteAfterPostingOnAfterDeleteLinks(var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDeleteAfterPostingOnBeforeDeleteSalesHeader(var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDeleteAfterPostingOnBeforeDeleteLinks(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforeCheckAndUpdate(var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateWonOpportunitiesOnBeforeOpportunityModify(var SalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; var Opportunity: Record Opportunity)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnBeforeCheckShip(var IsHandled: Boolean; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateReceiveAndCheckIfInvPutawayExists(var IsHandled: Boolean; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnModifyTempLineOnAfterSalesLineModify(var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnModifyTempLineOnBeforeTransferFields(var SalesLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnModifyTempLineOnBeforeSalesLineModify(var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnNeedUpdateGenProdPostingGroupOnItemChargeOnSalesLine(SalesLine: Record "Sales Line"; var NeedUpdate: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnNeedUpdateGenProdPostingGroupOnItemChargeOnSalesShipmentLine(SalesShipmentLine: Record "Sales Shipment Line"; var NeedUpdate: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnNeedUpdateGenProdPostingGroupOnItemChargeOnReturnReceiptLine(ReturnReceiptLine: Record "Return Receipt Line"; var NeedUpdate: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateSalesLineDimSetIDFromAppliedEntry(var SalesLineToPost: Record "Sales Line"; var ItemLedgEntry: Record "Item Ledger Entry"; DimSetID: array[10] of Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDeleteAfterPostingOnAfterSetupSalesHeader(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDeleteAfterPostingOnAfterSalesLineDeleteAll(SalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; CommitIsSuppressed: Boolean; EverythingInvoiced: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForShipmentConditionOnBeforeUpdateBlanketOrderLine(var TempSalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostResJnlLineOnAfterInit(var ResJnlLine: Record "Res. Journal Line"; var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValidatePostingAndDocumentDateOnAfterCalcPostingDateExists(var PostingDateExists: Boolean; var ReplacePostingDate: Boolean; var ReplaceDocumentDate: Boolean; var PostingDate: Date; var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean; var VATDateExists: Boolean; var ReplaceVATDate: Boolean; var VATDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeValidateICPartnerBusPostingGroups(var TempICGenJnlLine: Record "Gen. Journal Line" temporary; SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetCurrency(CurrencyCode: Code[10]; var Currency: Record Currency)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemChargeLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnBeforeInsertedPrepmtVATBaseToDeduct(var TempPrepmtSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertReturnReceiptHeader(var SalesHeader: Record "Sales Header"; var ReturnReceiptHeader: Record "Return Receipt Header")    begin    end;#if not CLEAN27    [Obsolete('This event is never raised.', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterGetAmountsForDeferral(SalesLine: Record "Sales Line"; var AmtToDefer: Decimal; var AmtToDeferACY: Decimal; var DeferralAccount: Code[20])    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnPostJobContractLineBeforeTestFields(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertCrMemoHeaderOnAfterCalcShouldProcessAsReturnOrder(SalesHeader: Record "Sales Header"; var ShouldProcessAsReturnOrder: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateQtyToBeInvoicedForShipmentOnAfterSetQtyToBeInvoiced(TrackingSpecificationExists: Boolean; HasATOShippedNotInvoiced: Boolean; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; RemQtyToBeInvoiced: Decimal; RemQtyToBeInvoicedBase: Decimal; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemJnlLineItemCharges(var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateReturnReceiptLineOnBeforeInitOutstanding(var SalesOrderLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForShipmentOnBeforeGetATOItemLedgEntriesNotInvoiced(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckSalesDocumentOnBeforeCheckDueDate(var SalesHeader: Record "Sales Header"; var ShouldCheckDueDate: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineTrackingOnAfterCalcShouldInsertTrkgSpecInv(var SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; var ShouldInsertTrkgSpecInv: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateSalesLineBeforePostOnBeforeGetUnitCost(var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcItemJnlAmountsFromQtyToBeInvoiced(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckTrackingAndWarehouseForReceiveOnAfterSetFilters(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforeCalcVATAmountLines(var TempSalesLineGlobal: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnTestSalesLineOnBeforeTestFieldQtyToShip(SalesLine: Record "Sales Line"; var ShouldTestQtyToShip: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertShipmentLine(var SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnIsEndLoopForShippedNotInvoicedOnBeforeExit(SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; RemQtyToBeInvoiced: Decimal; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLinePrepareJournalLineOnBeforeCalcQuantities(var ItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; var IsHandled: Boolean; IsATO: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInvoiceRounding(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterCopyTrackingFromSpec(var ItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; IsATO: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnBeforeValidateQtyToInvoice(var SalesHeader: Record "Sales Header"; var ShouldValidateQtyToInvoice: Boolean; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssosOrderPostingNosOnAfterSetFilterTempSalesLine(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckTrackingSpecificationOnBeforeGetItemTrackingSettings(var TempItemSalesLine: Record "Sales Line" temporary; var ItemTrackingSetup: Record "Item Tracking Setup"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingForReceipt(var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineTrackingOnBeforeInsertTempTrkgSpec(var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempTrackingSpec: Record "Tracking Specification" temporary; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertInvoiceHeaderOnBeforeCheckDocumentType(SalesHeader: Record "Sales Header"; var SalesInvHeader: Record "Sales Invoice Header"; SalesSetup: Record "Sales & Receivables Setup"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostInvoiceOnBeforePostBalancingEntry(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; var TotalSalesLine: Record "Sales Line"; var TotalSalesLineLCY: Record "Sales Line"; SuppressCommit: Boolean; PreviewMode: Boolean; InvoicePostingParameters: Record "Invoice Posting Parameters"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeFindNotShippedLines(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnBeforePostSalesLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; SrcCode: Code[10]; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var IsHandled: Boolean; SalesLineACY: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateInvoiceRounding(var SalesHeader: Record "Sales Header"; var TotalSalesLine: Record "Sales Line"; var SalesLine: Record "Sales Line"; var Currency: Record Currency; var BiggestLineNo: Integer; var LastLineRetrieved: Boolean; var RoundingLineInserted: Boolean; var RoundingLineNo: Integer; UseTempData: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnAfterSetFilters(var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostItemLineOnBeforePostItemJnlLineForInvoiceDoc(SalesHeader: Record "Sales Header"; var SalesLineToShip: Record "Sales Line"; Ship: Boolean; var ItemLedgShptEntryNo: Integer; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35]; SalesShptHeader: Record "Sales Shipment Header"; var TempHandlingSpecification: Record "Tracking Specification" temporary; var TempTrackingSpecificationInv: Record "Tracking Specification" temporary; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean; QtyToInvoice: Decimal; TempAssembletoOrderLink: Record "Posted Assemble-to-Order Link" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingOnAfterCalcShouldPostItemTrackingForReceipt(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal; QtyToInvoiceBaseInTrackingSpec: Decimal; var ShouldPostItemTrackingForReceipt: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingOnAfterCalcShouldPostItemTrackingForShipment(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal; QtyToInvoiceBaseInTrackingSpec: Decimal; var ShouldPostItemTrackingForShipment: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeGetQuantityShipped(var TempSalesLine: Record "Sales Line"; var IsHandled: Boolean; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeGetReturnQtyReceived(var TempSalesLine: Record "Sales Line"; var IsHandled: Boolean; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingOnAfterCalcShouldProcessReceipt(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var ShouldProcessReceipt: Boolean; var ItemJnlRollRndg: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnBeforeInitOutstanding(var SalesOrderLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostInvoiceOnBeforeBalAccountNoWindowUpdate(HideProgressWindow: Boolean; var IsHandled: Boolean; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnAfterCalcShouldCalcPrepmtAmounts(var TempSalesLine: Record "Sales Line" temporary; var ShouldCalcPrepmtAmounts: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetGeneralPostingSetup(var GeneralPostingSetup: Record "General Posting Setup"; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckItemTrackingQuantityOnDocumentTypeCaseElse(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetCommitBehavior(var ErrorOnCommit: Boolean)    begin    end;#if not CLEAN27    [IntegrationEvent(false, false)]    [Obsolete('This event is no longer used.', '27.0')]    local procedure OnSetPostingPreviewDocumentNo(var PreviewDocumentNo: Code[20]; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    [Obsolete('This event is no longer used.', '27.0')]    local procedure OnGetPostingPreviewDocumentNos(var PreviewDocumentNos: List of [Code[20]])    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnPostInvoiceOnAfterPostLines(var SalesHeader: Record "Sales Header"; SrcCode: Code[10]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCopyAndCheckItemChargeOnBeforeAssignQtyToInvoice(var TempSalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeItemLedgerEntryExist(var SalesLine: Record "Sales Line"; ShipOrReceive: Boolean; var HasItemLedgerEntry: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertPostedHeadersOnAfterCalcShouldInsertInvoiceHeader(var SalesHeader: Record "Sales Header"; var ShouldInsertInvoiceHeader: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertShptEntryRelationOnAfterItemEntryRelationInsert(SalesShipmentLine: Record "Sales Shipment Line"; var ItemEntryRelation: Record "Item Entry Relation"; xSalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemChargePerRetRcpt(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeSetInvoiceFields(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line"; var ShouldSetInvoiceFields: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCopyAndCheckItemChargeOnBeforeError(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var InvoiceEverything: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetSalesLineAdjCostLCY(SalesLine2: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; AdjCostLCY: Decimal; var Result: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnBeforeShouldTestGetShipmentPPmtAmtToDeduct(SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean; var ShouldTestGetShipmentPPmtAmtToDeduct: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterDeleteApprovalEntries(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var ReturnReceiptHeader: Record "Return Receipt Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnBeforeUpdateSalesLineBeforePost(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; RoundingLineInserted: Boolean; CommitIsSuppressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSumSalesLines2(var SalesHeader: Record "Sales Header"; var OldSalesLine: Record "Sales Line"; var NewSalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckPostWhseShptLinesOnAfterWhseShptLinesFound(var SalesShipmentLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line"; var WhseShptLinesFound: Boolean; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; WhseShip: Boolean; WhseReceive: Boolean; var WarehouseShipmentLine: Record "Warehouse Shipment Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterDecrementPrepmtAmtInvLCY(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var PrepmtAmountInvLCY: Decimal; var PrepmtVATAmountInvLCY: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnBeforeTempVATAmountLineGet(SalesLine: Record "Sales Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeAdjustPrepmtAmountLCY(SalesHeader: Record "Sales Header"; var PrepmtSalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostResJnlLineOnShouldExit(var SalesLine: Record "Sales Line"; var ShouldExit: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnBeforeUpdateTempVATAmountLineRemainder(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; Currency: Record Currency; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargeOnAfterCalcTotalChargeAmt(var SalesLineToPost: Record "Sales Line"; QtyToAssign: Decimal; var SalesLine: Record "Sales Line"; xSalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPostRestrictions(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnBeforeValidateType(var TempPrepmtSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValidatePostingAndDocumentDateOnBeforeValidateDocumentDate(var PostingDateExists: Boolean; var ReplaceDocumentDate: Boolean; var PostingDate: Date; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckSalesDocumentOnBeforeCheckSalesDim(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreatePrepaymentTextLines(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckAndUpdate(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnBeforeCollectValueEntryRelation(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesInvoiceLine: Record "Sales Invoice Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnBeforeCollectValueEntryRelationForCrMemo(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesInvoiceLine: Record "Sales Invoice Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnAfterCollectValueEntryRelation(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesInvoiceLine: Record "Sales Invoice Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSalesLineOnAfterCreatePostedDeferralSchedule(var SalesInvLine: Record "Sales Invoice Line"; SalesInvHeader: Record "Sales Invoice Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInvoiceRoundingOnAfterValidateQuantity(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInvoiceRoundingOnAfterSetLineNo(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised before updating won opportunities after posting a sales invoice.    /// </summary>    /// <param name="SalesHeader">The sales header that was posted.</param>    /// <param name="SalesInvHeader">The posted sales invoice header.</param>    /// <param name="IsHandled">Set to true to skip the default opportunity update logic.</param>    [IntegrationEvent(false, false)]    procedure OnBeforeUpdateWonOpportunities(var SalesHeader: Record "Sales Header"; SalesInvHeader: Record "Sales Invoice Header"; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertPostedHeadersOnBeforeDeleteServItemOnSaleCreditMemo(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertPostedHeadersOnAfterInsertInvoiceHeader(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertPostedHeadersOnAfterInsertCrMemoHeader(var SalesHeader: Record "Sales Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header")    begin    end;    /// <summary>    /// Raised before making inventory adjustments after posting.    /// </summary>    /// <param name="InvtSetup">The inventory setup record.</param>    /// <param name="InvtAdjmtHandler">The inventory adjustment handler codeunit.</param>    /// <param name="IsHandled">Set to true to skip the default inventory adjustment logic.</param>    [IntegrationEvent(false, false)]    procedure OnBeforeMakeInventoryAdjustment(var InvtSetup: Record "Inventory Setup"; var InvtAdjmtHandler: Codeunit "Inventory Adjustment Handler"; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnProcessPostingLinesOnBeforePostDropOrderShipment(SalesHeader: Record "Sales Header"; TotalSalesLine: Record "Sales Line"; TotalSalesLineLCY: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterArchiveUnpostedOrder(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; OrderArchived: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckReturnRcptLine(var ReturnReceiptLine: Record "Return Receipt Line"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertReturnReceiptHeaderOnBeforeReturnReceiptHeaderTransferFields(var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCopyAndCheckItemCharge(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var SalesLine: Record "Sales Line"; var InvoiceEverything: Boolean; var AssignError: Boolean; var QtyNeeded: Decimal; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; var ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)"; var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValidatePostingAndDocumentDateOnBeforeTestPostingDate(var SalesHeader: Record "Sales Header"; ReplacePostingDate: Boolean; var SkipTestPostingDate: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValidatePostingAndDocumentDateOnBeforeSalesHeaderModify(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForShipmentOnBeforeTestLineFields(var SalesShipmentLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateQtyToBeInvoicedForReturnReceiptOnAfterSetQtyToBeInvoiced(TrackingSpecificationExists: Boolean; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; RemQtyToBeInvoiced: Decimal; RemQtyToBeInvoicedBase: Decimal; var SalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertPostedHeadersOnAfterInsertShipmentHeader(var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertPostedHeadersDeleteServItemOnSaleCreditMemo(var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunWithCheckOnAfterFinalize(var SalesHeader: Record "Sales Header");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeFinalizePostATO(var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteATOLinks(SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckATOLink(SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSumSalesLinesTempOnAfterVatAmountSet(var VATAmount: Decimal; var TotalSalesLine: Record "Sales Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertShptEntryRelationOnBeforeDeleteTempHandlingSpecification(var TempHandlingTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssosOrderPostingNosOnBeforeModifyPurchOrderHeader(var PurchaseOrderHeader: Record "Purchase Header"; var SalesHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostJobContractLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var GenJnlLineDocType: Enum "Gen. Journal Document Type"; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35]; var SrcCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostDistributeItemCharge(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempItemLedgerEntry: Record "Item Ledger Entry"; NonDistrQuantity: Decimal; NonDistrQtyToAssign: Decimal; NonDistrAmountToAssign: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDistributeItemChargeOnAfterSetFactor(TempItemLedgerEntry: Record "Item Ledger Entry"; var Factor: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcPrepmtAmtToDeduct(var SalesLine: Record "Sales Line"; Ship: Boolean; var IsHandled: Boolean; var PrepmtAmtToDeduct: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemJournalLineWarehouseLine(var TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemJournalLineWarehouseLine(var TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAdjustPrepmtAmountLCYOnAfterGetOrderLine(var SalesLine: Record "Sales Line"; var SalesInvoiceLine: Record "Sales Line");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetQtyToInvoice(SalesLine: Record "Sales Line"; Ship: Boolean; var IsHandled: Boolean; var QtyToInvoice: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeAdjustFinalInvWith100PctPrepmt(var TempPrepmtDeductLCYSalesLine: Record "Sales Line" temporary; var CombinedSalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateRemainingQtyToBeInvoiced(SalesShptLine: Record "Sales Shipment Line"; var RemQtyToInvoiceCurrLine: Decimal; var RemQtyToInvoiceCurrLineBase: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLineForCreditMemoOnBeforeGetSalesPrepmtAccount(var GLAccount: Record "G/L Account"; var SalesInvoiceLine: Record "Sales Invoice Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateEmailParameters(SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostUpdateOrderNo(var SalesInvoiceHeader: Record "Sales Invoice Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetInvoiceOrderNo(SalesLine: Record "Sales Line"; var SalesInvLine: Record "Sales Invoice Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeArchiveRelatedJob(SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSyncSurPlusItemTrackingOnBeforeModifyQtyToHandleInvoice(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; var ReservationEntry: Record "Reservation Entry")    begin    end;}