Codeunit 90 Purch.-Post

Base Application, Microsoft.Purchases.Posting

src/Layers/W1/BaseApp/Purchases/Posting/PurchPost.Codeunit.al11,571 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.Purchases.Posting;using Microsoft.CRM.Contact;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.FixedAssets.Setup;using Microsoft.Foundation.AuditCodes;using Microsoft.Foundation.BatchProcessing;using Microsoft.Foundation.ExtendedText;using Microsoft.Foundation.NoSeries;using Microsoft.Foundation.UOM;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.Inventory.Transfer;using Microsoft.Projects.Project.Job;using Microsoft.Projects.Project.Planning;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.Payables;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.Posting;using Microsoft.Sales.Setup;using Microsoft.Utilities;using Microsoft.Warehouse.Activity;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.Environment.Configuration;using System.Utilities;codeunit 90 "Purch.-Post"{    Permissions = TableData "Sales Header" = rm,                  TableData "Sales Line" = rm,                  TableData "Purchase Header" = rimd,                  TableData "Purchase Line" = rimd,                  TableData "Vendor Posting Group" = rimd,                  TableData "Inventory Posting Group" = rimd,                  TableData "Sales Shipment Header" = rimd,                  TableData "Sales Shipment Line" = rimd,                  TableData "Purch. Rcpt. Header" = rimd,                  TableData "Purch. Rcpt. Line" = rimd,                  TableData "Purch. Inv. Header" = rimd,                  TableData "Purch. Inv. Line" = rimd,                  TableData "Purch. Cr. Memo Hdr." = rimd,                  TableData "Purch. Cr. Memo Line" = rimd,                  TableData "Drop Shpt. Post. Buffer" = rimd,                  TableData "Item Entry Relation" = ri,                  TableData "Value Entry Relation" = rid,                  TableData "Return Shipment Header" = rimd,                  TableData "Return Shipment Line" = rimd,                  tabledata "G/L Entry" = r;    TableNo = "Purchase Header";    EventSubscriberInstance = Manual;    trigger OnRun()    begin        RunWithCheck(Rec);    end;    /// <summary>    /// Verifies and posts the purchase 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 received and/or invoiced.    /// A Return order can be shipped 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="PurchaseHeader2">The purchase header of the document that is being posted.</param>    internal procedure RunWithCheck(var PurchaseHeader2: Record "Purchase Header")    var        PurchHeader: Record "Purchase Header";        TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary;        SequenceNoMgt: Codeunit "Sequence No. Mgt.";        EverythingInvoiced: Boolean;        SavedPreviewMode: Boolean;        SavedSuppressCommit: Boolean;        SavedCalledBy: Integer;        SavedHideProgressWindow: Boolean;        IsHandled: Boolean;    begin        SequenceNoMgt.SetPreviewMode(PreviewMode);        IsHandled := false;        OnBeforePostPurchaseDoc(PurchaseHeader2, PreviewMode, SuppressCommit, HideProgressWindow, ItemJnlPostLine, IsHandled);        if IsHandled then            exit;        GetPurchaseHeader(PurchaseHeader2);        if not GuiAllowed() then            LockTimeout(false);        ValidatePostingAndDocumentDate(PurchaseHeader2);        SavedPreviewMode := PreviewMode;        SavedSuppressCommit := SuppressCommit;        SavedHideProgressWindow := HideProgressWindow;        SavedCalledBy := CalledBy;        ClearAllVariables();        PreviewMode := SavedPreviewMode;        SuppressCommit := SavedSuppressCommit;        HideProgressWindow := SavedHideProgressWindow;        CalledBy := SavedCalledBy;        GetGLSetup();        GetPurchSetup();        GetInvoicePostingSetup();        GetCurrency(PurchaseHeader2."Currency Code");        PurchHeader := PurchaseHeader2;        OnRunOnBeforeFillTempLines(PreviewMode, GenJnlLineDocNo);        FillTempLines(PurchHeader, TempPurchLineGlobal);        OnRunOnAfterFillTempLines(PurchHeader);        // Header        CheckAndUpdate(PurchHeader);        ProcessPosting(PurchHeader, TempDropShptPostBuffer, EverythingInvoiced);        UpdateLastPostingNos(PurchHeader);        OnRunOnBeforeFinalizePosting(          PurchHeader, PurchRcptHeader, PurchInvHeader, PurchCrMemoHeader, ReturnShptHeader, GenJnlPostLine, SuppressCommit);        FinalizePosting(PurchHeader, TempDropShptPostBuffer, EverythingInvoiced);        PurchaseHeader2 := PurchHeader;        CommitAndUpdateAnalysisVeiw();        OnAfterPostPurchaseDoc(          PurchaseHeader2, GenJnlPostLine, PurchRcptHeader."No.", ReturnShptHeader."No.", PurchInvHeader."No.", PurchCrMemoHeader."No.",          SuppressCommit);        OnAfterPostPurchaseDocDropShipment(SalesShptHeader."No.", SuppressCommit, PreviewMode);    end;    /// <summary>    /// A wrapper procedure to delegate to either a procedure that allows commit or a procedure that ignores commit.    /// By default, commits are suppressed during the critical posting window to prevent duplicate-key races    /// on G/L Entry (table 17). Subscribers can opt out by setting IgnoreCommit to false via OnSetCommitBehavior.    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="TempDropShptPostBuffer">Accumulates drop-shipment buffer records during posting.</param>    /// <param name="EverythingInvoiced">Set to false during posting if any line is partially invoiced.</param>    local procedure ProcessPosting(var PurchHeader: Record "Purchase Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var EverythingInvoiced: Boolean)    var        IgnoreCommit: Boolean;    begin        IgnoreCommit := true;        OnSetCommitBehavior(IgnoreCommit);        if IgnoreCommit then            ProcessPostingLinesCommitBehaviorIgnore(PurchHeader, TempDropShptPostBuffer, EverythingInvoiced)        else            ProcessPostingLines(PurchHeader, TempDropShptPostBuffer, EverythingInvoiced);    end;    /// <summary>    /// A wrapper procedure to delegate to ProcessPostingLines in order to ignore commits.    /// While this procedure is on the call stack, the platform turns every Commit() into a no-op,    /// preventing intermittent duplicate-key errors on G/L Entry (table 17).    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="TempDropShptPostBuffer">Accumulates drop-shipment buffer records during posting.</param>    /// <param name="EverythingInvoiced">Set to false during posting if any line is partially invoiced.</param>    [CommitBehavior(CommitBehavior::Ignore)]    local procedure ProcessPostingLinesCommitBehaviorIgnore(        var PurchHeader: Record "Purchase Header";        var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary;        var EverythingInvoiced: Boolean)    begin        ProcessPostingLines(PurchHeader, TempDropShptPostBuffer, EverythingInvoiced);    end;    /// <summary>    /// The main procedure that processes the purchase document lines.    /// Will update inventory, finance, resources, jobs, etc., dependent on what lines are in the document.    /// Also covers PostInvoice, PostICGenJnl, and MakeInventoryAdjustment.    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="TempDropShptPostBuffer">Accumulates drop-shipment buffer records during posting.</param>    /// <param name="EverythingInvoiced">Set to false during posting if any line is partially invoiced.</param>    local procedure ProcessPostingLines(        var PurchHeader: Record "Purchase Header";        var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary;        var EverythingInvoiced: Boolean)    var        TempVATAmountLine: Record "VAT Amount Line" temporary;        TempVATAmountLineRemainder: Record "VAT Amount Line" temporary;        ErrorContextElementProcessLines: Codeunit "Error Context Element";        ErrorContextElementPostLine: Codeunit "Error Context Element";        ZeroPurchLineRecID: RecordId;        ICGenJnlLineNo: Integer;        BiggestLineNo: Integer;        IsHandled: Boolean;    begin        InvoicePostingInterface.ClearBuffers();        TempDropShptPostBuffer.DeleteAll();        EverythingInvoiced := true;        // Lines        GetZeroPurchLineRecID(PurchHeader, ZeroPurchLineRecID);        ErrorMessageMgt.PushContext(ErrorContextElementProcessLines, ZeroPurchLineRecID, 0, PostDocumentLinesMsg);        OnBeforePostLines(TempPurchLineGlobal, PurchHeader, PreviewMode, SuppressCommit, TempPurchLineGlobal, TempWhseShptHeader, TempWhseRcptHeader);        MatchedOrderLineMgmt.ProcessMatchedReceiptOnInvoice(TempPurchLineGlobal);        LineCount := 0;        RoundingLineInserted := false;        AdjustFinalInvWith100PctPrepmt(TempPurchLineGlobal);        TempVATAmountLineRemainder.DeleteAll();        TempPurchLineGlobal.CalcVATAmountLines(1, PurchHeader, TempPurchLineGlobal, TempVATAmountLine);        OnRunOnAfterCalcVATAmountLines(PurchHeader, TempPurchLineGlobal, TempVATAmountLine);        Clear(PostponedValueEntries);        BindSubscription(this); // Start collect value entries for GLPosting        PurchaseLinesProcessed := false;        if not InventorySetup.UseLegacyPosting() then            TempPurchLineGlobal.SetCurrentKey(Type, "Line No.");        if TempPurchLineGlobal.FindSet() then            repeat                IsHandled := false;                OnRunOnBeforePostPurchLine(TempPurchLineGlobal, PurchHeader, IsHandled);                if not IsHandled then begin                    ErrorMessageMgt.PushContext(ErrorContextElementPostLine, TempPurchLineGlobal.RecordId, 0, PostDocumentLinesMsg);                    ItemJnlRollRndg := false;                    LineCount := LineCount + 1;                    if GuiAllowed() and not HideProgressWindow then                        Window.Update(2, LineCount);                    PostPurchLine(                      PurchHeader, TempPurchLineGlobal, TempVATAmountLine, TempVATAmountLineRemainder,                      TempDropShptPostBuffer, EverythingInvoiced, ICGenJnlLineNo);                    OnRunOnAfterPostPurchLine(TempPurchLineGlobal, PurchInvHeader, PurchCrMemoHeader, PurchRcptHeader, ReturnShptHeader);                end;                if RoundingLineInserted then                    LastLineRetrieved := true                else begin                    BiggestLineNo := MAX(BiggestLineNo, TempPurchLineGlobal."Line No.");                    LastLineRetrieved := TempPurchLineGlobal.Next() = 0;                    if LastLineRetrieved and PurchSetup."Invoice Rounding" then                        InvoiceRounding(PurchHeader, TempPurchLineGlobal, false, BiggestLineNo);                    OnRunOnAfterInvoiceRounding(PurchHeader, TempPurchLineGlobal);                end;                ErrorMessageMgt.PopContext(ErrorContextElementPostLine);            until LastLineRetrieved;        TempPurchLineGlobal.SetCurrentKey("Document Type", "Document No.", "Line No.");        UnBindSubscription(this); // Stop collecting value entries for GLPosting        ItemJnlPostLine.PostDeferredValueEntriesToGL(PostponedValueEntries);        OnAfterProcessPurchLines(          PurchHeader, PurchRcptHeader, PurchInvHeader, PurchCrMemoHeader, ReturnShptHeader,          WhseShip, WhseReceive, PurchaseLinesProcessed, SuppressCommit, EverythingInvoiced);        ErrorMessageMgt.PopContext(ErrorContextElementProcessLines);        ErrorMessageMgt.Finish(ZeroPurchLineRecID);        if PurchHeader.IsCreditDocType() then begin            ReverseAmount(TotalPurchLine);            ReverseAmount(TotalPurchLineLCY);        end;        // Post combine shipment of sales order        PostCombineSalesOrderShipment(PurchHeader, TempDropShptPostBuffer);        OnRunOnBeforePostInvoice(PurchHeader, EverythingInvoiced);        if PurchHeader.Invoice then            PostInvoice(PurchHeader);        OnRunOnAfterPostInvoice(PurchHeader, PurchRcptHeader, ReturnShptHeader, PurchInvHeader, PurchCrMemoHeader, PreviewMode, Window, SrcCode, GenJnlLineDocType, GenJnlLineDocNo, GenJnlPostLine);        if ICGenJnlLineNo > 0 then            PostICGenJnl();        IsHandled := false;        OnRunOnBeforeMakeInventoryAdjustment(PurchHeader, GenJnlPostLine, ItemJnlPostLine, PreviewMode, PurchRcptHeader, PurchInvHeader, IsHandled);        if not IsHandled then            MakeInventoryAdjustment();    end;    var#pragma warning disable AA0470        PostingLinesMsg: Label 'Posting lines              #2######\', Comment = 'Counter';        PostingPurchasesAndVATMsg: Label 'Posting purchases and VAT  #3######\', Comment = 'Counter';        PostingVendorsMsg: Label 'Posting to vendors         #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.';        ReceiptSameSignErr: Label 'must have the same sign as the receipt';        ReceiptLinesDeletedErr: Label 'Receipt lines have been deleted.';        PurchaseAlreadyExistsErr: Label 'Purchase %1 %2 already exists for this vendor.', Comment = '%1 = Document Type, %2 = Document No.';        InvoiceMoreThanReceivedErr: Label 'You cannot invoice order %1 for more than you have received.', Comment = '%1 = Order No.';#if not CLEAN28        CannotPostBeforeAssosSalesOrderErr: Label 'You cannot post this purchase order before the associated sales orders have been invoiced. Post sales order %1 before posting this purchase order.', Comment = '%1 = Sales Order No.';#endif        ExtDocNoNeededErr: Label 'You need to enter the document number of the document from the vendor in the %1 field, so that this document stays linked to the original.', Comment = '%1 = Field caption of e.g. Vendor Invoice 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 be reduced';        ReceiveInvoiceShipErr: Label 'Please enter "Yes" in Receive and/or Invoice and/or Ship.';        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.';        ReturnShipmentSamesSignErr: Label 'must have the same sign as the return shipment';        ReturnShipmentInvoicedErr: Label 'Line %1 of the return shipment %2, which you are attempting to invoice, has already been invoiced.', Comment = '%1 = Line No., %2 = Document No.';        ReceiptInvoicedErr: Label 'Line %1 of the receipt %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 receipt %1.', Comment = '%1 = Receipt 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.';        CannotAssignInvoicedErr: Label 'You cannot assign item charges to the %1 %2 = %3,%4 = %5, %6 = %7, because it has been invoiced.', Comment = '%1 = Purchase Line, %2/%3 = Document Type, %4/%5 - Document No.,%6/%7 = Line No.';        CheckTotalAmountPurchLinesErr: Label '%1 (%2) is not equal to total of lines (%3)', Comment = '%1 = FieldCaption of Doc. Amount Incl. VAT; %2 - Doc. Amount Incl. VAT; %3 - Amount Including VAT ';        CheckTotalAmountVATPurchLinesErr: Label '%1 (%2) is not equal to total of VAT on lines (%3)', Comment = '%1 - Doc. Amount VAT; %2 - Doc. Amount VAT; %3 - Amount Including VAT - PurchHeader.Amount';        PurchSetup: Record "Purchases & Payables Setup";        GLSetup: Record "General Ledger Setup";        InventorySetup: Record "Inventory Setup";        [SecurityFiltering(SecurityFilter::Ignored)]        GLEntry: Record "G/L Entry";        TempPurchLineGlobal: Record "Purchase Line" temporary;        JobPurchLine: Record "Purchase Line";        TotalPurchLine: Record "Purchase Line";        TotalPurchLineLCY: Record "Purchase Line";        xPurchLine: Record "Purchase Line";        PurchLineACY: Record "Purchase Line";        PurchRcptHeader: Record "Purch. Rcpt. Header";        PurchInvHeader: Record "Purch. Inv. Header";        PurchCrMemoHeader: Record "Purch. Cr. Memo Hdr.";        ReturnShptHeader: Record "Return Shipment Header";        SalesShptHeader: Record "Sales Shipment Header";        TempItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)" temporary;        InvoicePostingParameters: Record "Invoice Posting Parameters";        SourceCodeSetup: Record "Source Code Setup";        Currency: Record Currency;        CurrExchRate: Record "Currency Exchange Rate";        VendLedgEntry: Record "Vendor Ledger Entry";        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;        TempTrackingSpecification: Record "Tracking Specification" temporary;        TempTrackingSpecificationInv: Record "Tracking Specification" temporary;        TempWhseSplitSpecification: Record "Tracking Specification" temporary;        TempValueEntryRelation: Record "Value Entry Relation" temporary;        Job: Record Job;        TempICGenJnlLine: Record "Gen. Journal Line" temporary;        TempPrepmtDeductLCYPurchLine: Record "Purchase 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";        ItemJnlPostLine: Codeunit "Item Jnl.-Post Line";        PurchLineReserve: Codeunit "Purch. Line-Reserve";        ApprovalsMgmt: Codeunit "Approvals Mgmt.";        WhsePurchRelease: Codeunit "Whse.-Purch. Release";        SalesPost: Codeunit "Sales-Post";        ItemTrackingMgt: Codeunit "Item Tracking Management";        WhseJnlPostLine: Codeunit "Whse. Jnl.-Register Line";        WhsePostRcpt: Codeunit "Whse.-Post Receipt";        WhsePostShpt: Codeunit "Whse.-Post Shipment";        CostCalcMgt: Codeunit "Cost Calculation Management";        JobPostLine: Codeunit "Job Post-Line";        DocumentErrorsMgt: Codeunit "Document Errors Mgt.";        DeferralUtilities: Codeunit "Deferral Utilities";        UOMMgt: Codeunit "Unit of Measure Management";        ApplicationAreaMgmt: Codeunit "Application Area Mgmt.";        NonDeductibleVAT: Codeunit "Non-Deductible VAT";        MatchedOrderLineMgmt: Codeunit "Matched Order Line Mgmt.";        InvoicePostingInterface: Interface "Invoice Posting";        IsInterfaceInitialized: Boolean;        Window: Dialog;        GenJnlLineDocNo: Code[20];        GenJnlLineExtDocNo: Code[35];        SrcCode: Code[10];        ItemLedgShptEntryNo: Integer;        GenJnlLineDocType: Enum "Gen. Journal Document Type";        LineCount: Integer;        RoundingLineNo: Integer;        RemQtyToBeInvoiced: Decimal;        RemQtyToBeInvoicedBase: Decimal;        RemAmt: Decimal;        RemDiscAmt: Decimal;        TotalChargeAmt: Decimal;        TotalChargeAmtLCY: Decimal;        RoundedPrevTotalChargeAmt: Decimal;        PreciseTotalChargeAmt: Decimal;        RoundedPrevTotalChargeAmtACY: Decimal;        PreciseTotalChargeAmtACY: Decimal;        LastLineRetrieved: Boolean;        RoundingLineInserted: Boolean;        DropShipOrder: Boolean;        GLSetupRead: Boolean;        InvtSetupRead: Boolean;        LogErrorMode: Boolean;        PurchSetupRead: Boolean;        PostponedValueEntries: List of [Integer];        ItemsToAdjust: List of [Code[20]];        InvoiceGreaterThanReturnShipmentErr: Label 'The quantity you are attempting to invoice is greater than the quantity in return shipment %1.', Comment = '%1 = Return Shipment No.';        ReturnShipmentLinesDeletedErr: Label 'Return shipment lines have been deleted.';        InvoiceMoreThanShippedErr: Label 'You cannot invoice return order %1 for more than you have shipped.', Comment = '%1 = Order No.';        RelatedItemLedgEntriesNotFoundErr: Label 'Related item ledger entries cannot be found.';        ItemTrackingWrongSignErr: Label 'Item Tracking is signed wrongly.';        ItemTrackingMismatchErr: Label 'Item Tracking does not match.';        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';        ItemJnlRollRndg: Boolean;        WhseReceive: Boolean;        WhseShip: Boolean;        InvtPickPutaway: Boolean;        DocumentIsReadyToBeChecked: 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';        UnpostedInvoiceDuplicateQst: Label 'An unposted invoice for order %1 exists. To avoid duplicate postings, delete order %1 or invoice %2.\Do you still want to post order %1?', Comment = '%1 = Order No.,%2 = Invoice No.';#pragma warning disable AA0470        InvoiceDuplicateInboxQst: Label 'An invoice for order %1 exists in the IC inbox. To avoid duplicate postings, cancel invoice %2 in the IC inbox.\Do you still want to post order %1?', Comment = '%1 = Order No.';#pragma warning restore AA0470        PostedInvoiceDuplicateQst: Label 'Posted invoice %1 already exists for order %2. To avoid duplicate postings, do not post order %2.\Do you still want to post order %2?', Comment = '%1 = Invoice No., %2 = Order No.';        OrderFromSameTransactionQst: Label 'Order %1 originates from the same IC transaction as invoice %2. To avoid duplicate postings, delete order %1 or invoice %2.\Do you still want to post invoice %2?', Comment = '%1 = Order No., %2 = Invoice No.';        DocumentFromSameTransactionQst: Label 'A document originating from the same IC transaction as document %1 exists in the IC inbox. To avoid duplicate postings, cancel document %2 in the IC inbox.\Do you still want to post document %1?', Comment = '%1 and %2 = Document No.';        PostedInvoiceFromSameTransactionQst: Label 'Posted invoice %1 originates from the same IC transaction as invoice %2. To avoid duplicate postings, do not post invoice %2.\Do you still want to post invoice %2?', Comment = '%1 and %2 = Invoice No.';        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.';        PurchaseLinesProcessed: Boolean;#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        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.';        CalledBy: Integer;        PreviewMode: Boolean;        MixedDerpFAUntilPostingDateErr: Label 'The value in the Depr. Until FA Posting Date field must be the same on lines for the same fixed asset %1.', Comment = '%1 - Fixed Asset No.';        CannotPostSameMultipleFAWhenDeprBookValueZeroErr: Label 'You cannot select the Depr. Until FA Posting Date check box because there is no previous acquisition entry for fixed asset %1.\\If you want to depreciate new acquisitions, you can select the Depr. Acquisition Cost check box instead.', Comment = '%1 - Fixed Asset No.';        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.';        SuppressCommit: Boolean;        OrderArchived: Boolean;        CheckPurchHeaderMsg: Label 'Check purchase document fields.';        CheckPurchLineMsg: Label 'Check purchase document line.';        HideProgressWindow: Boolean;        DateOrderSeriesUsed: Boolean;        SuppressCommitErr: Label 'Commit is blocked when %1 %2 is used.', Comment = '%1 = Date Order, %2 = Number Series';        OverReceiptApprovalErr: Label 'There are lines with over-receipt required for approval.';        PostDocumentLinesMsg: Label 'Post document lines.';        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.';        PurchRcptHeaderConflictErr: Label 'Cannot post the purchase receipt because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Receiving No.';        ReturnShptHeaderConflictErr: Label 'Cannot post the return shipment because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Return Shipment No.';        PurchInvHeaderConflictErr: Label 'Cannot post the purchase invoice because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Posting No.';        PurchCrMemoHeaderConflictErr: Label 'Cannot post the purchase credit memo because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Posting No.';        PurchLinePostCategoryTok: Label 'Purchase 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.';        ConfirmUsageWithBlankLineTypeQst: Label 'Usage will not be linked to the project planning line because the Line Type field is empty.\\Do you want to continue?';        ConfirmUsageWithBlankJobPlanningLineNoQst: Label 'Usage will not be linked to the project planning line because the Project Planning Line No field is empty.\\Do you want to continue?';        SelfBillingNoSeriesMissingErr: Label 'Specify a number series for self-billing invoices in the %1 field on vendor %2, or in the %3 field in %4.', Comment = '%1 = Self-Billing Invoice Nos. field caption, %2 = Vendor No., %3 = Posted Self-Billing Inv. Nos. field caption, %4 = Purchases & Payables Setup table caption';    /// <summary>    /// Generates a record id for an 'empty' line    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="PurchLineRecID">Return value: The record ID of the 'empty' line.</param>    local procedure GetZeroPurchLineRecID(PurchHeader: Record "Purchase Header"; var PurchLineRecID: RecordId)    var        ZeroPurchLine: Record "Purchase Line";    begin        ZeroPurchLine."Document Type" := PurchHeader."Document Type";        ZeroPurchLine."Document No." := PurchHeader."No.";        ZeroPurchLine."Line No." := 0;        PurchLineRecID := ZeroPurchLine.RecordId;    end;    /// <summary>    /// Copies all the purchase lines to a temporary table to speed up later processing    /// </summary>    /// <remarks>    /// If the Item Charge exists for an Item in Purchase Line, then Gen. Prod. posting Group of Item Charge is copied to the Purchase Line.    /// </remarks>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="TempPurchLine">Return value: The temp table that holds a copy of all purchase lines.</param>    procedure CopyToTempLines(PurchHeader: Record "Purchase Header"; var TempPurchLine: Record "Purchase Line" temporary)    var        PurchLine: Record "Purchase Line";    begin        PurchLine.SetRange("Document Type", PurchHeader."Document Type");        PurchLine.SetRange("Document No.", PurchHeader."No.");        OnCopyToTempLinesOnAfterSetFilters(PurchLine, PurchHeader);        if PurchLine.FindSet() then            repeat                OnCopyToTempLinesLoop(PurchLine);                UpdateChargeItemPurchaseLineGenProdPostingGroup(PurchLine);                TempPurchLine := PurchLine;                TempPurchLine.Insert();            until PurchLine.Next() = 0;        OnAfterCopyToTempLines(TempPurchLine, PurchHeader);    end;    /// <summary>    /// When doing actual posting (not preview) commits the transaction while updating Analysis and Item Analysis views    /// </summary>    /// <remarks>    /// Data is not committed and analysis views not updated if either posting was called from warehouse document, posting is done as a preview or SuppressCommit was set.    /// </remarks>    local procedure CommitAndUpdateAnalysisVeiw()    var        UpdateAnalysisView: Codeunit "Update Analysis View";        UpdateItemAnalysisView: Codeunit "Update Item Analysis View";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCommitAndUpdateAnalysisVeiw(InvtPickPutaway, SuppressCommit, PreviewMode, IsHandled);        if IsHandled then            exit;        if not (InvtPickPutaway or SuppressCommit or PreviewMode) then begin            Commit();            UpdateAnalysisView.UpdateAll(0, true);            UpdateItemAnalysisView.UpdateAll(0, true);        end;    end;    /// <summary>    /// Copies all the purchase lines to a temporary table, if they haven't been copied yet, to speed up later processing     /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="TempPurchLine">Return value: The temp table that holds a copy of all purchase lines.</param>    procedure FillTempLines(PurchHeader: Record "Purchase Header"; var TempPurchLine: Record "Purchase Line" temporary)    begin        TempPurchLine.Reset();        if TempPurchLine.IsEmpty() then            CopyToTempLines(PurchHeader, TempPurchLine);    end;    /// <summary>    /// Updates actual purchase line with information from temporary purchase line    /// </summary>    /// <param name="TempPurchLineLocal">Return value: The temp table that holds a copy of all purchase lines.</param>    local procedure ModifyTempLine(var TempPurchLineLocal: Record "Purchase Line" temporary)    var        PurchLine: Record "Purchase Line";    begin        OnBeforeModifyTempLine(TempPurchLineLocal);        TempPurchLineLocal.Modify();        PurchLine.Get(TempPurchLineLocal.RecordId);        OnModifyTempLineOnBeforeTransferFields(PurchLine, TempPurchLineLocal);        PurchLine.TransferFields(TempPurchLineLocal, false);        PurchLine.Modify();        OnAfterModifyTempLine(PurchLine);    end;    /// <summary>    /// Recreates all temporary purchase lines    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="TempPurchLine">Return value: The temp table that holds a copy of all purchase lines.</param>    procedure RefreshTempLines(PurchHeader: Record "Purchase Header"; var TempPurchLine: Record "Purchase Line" temporary)    begin        TempPurchLine.Reset();        TempPurchLine.SetRange("Prepayment Line", false);        TempPurchLine.DeleteAll();        TempPurchLine.Reset();        CopyToTempLines(PurchHeader, TempPurchLine);        OnAfterRefreshTempLines(TempPurchLine);    end;    /// <summary>    /// Removes all filters from temporary purchase lines and copies them from the global temp table    /// </summary>    /// <param name="TempPurchLineLocal">Return value: The temp table that holds a copy of all purchase lines.</param>    procedure ResetTempLines(var TempPurchLineLocal: Record "Purchase Line" temporary)    begin        TempPurchLineLocal.Reset();        TempPurchLineLocal.Copy(TempPurchLineGlobal, true);        OnAfterResetTempLines(TempPurchLineGlobal);    end;    /// <summary>    /// Checks if a new posted invoice should be created for the document    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <returns>True if a new invoice should be created, false otherwise.</returns>    procedure CalcInvoice(var PurchHeader: Record "Purchase Header") NewInvoice: Boolean    var        TempPurchLine: Record "Purchase Line" temporary;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcInvoice(PurchHeader, NewInvoice, IsHandled);        if IsHandled then            exit(NewInvoice);        ResetTempLines(TempPurchLine);        IsHandled := false;        OnCalcInvoiceOnAfterResetTempLines(PurchHeader, TempPurchLine, NewInvoice, IsHandled);        if IsHandled then            exit(NewInvoice);        TempPurchLine.SetFilter(Quantity, '<>0');        if PurchHeader."Document Type" in [PurchHeader."Document Type"::Order, PurchHeader."Document Type"::"Return Order"] then            TempPurchLine.SetFilter("Qty. to Invoice", '<>0');        NewInvoice := not TempPurchLine.IsEmpty();        if NewInvoice then            case PurchHeader."Document Type" of                PurchHeader."Document Type"::Order:                    if not PurchHeader.Receive then begin                        TempPurchLine.SetFilter("Qty. Rcd. Not Invoiced", '<>0');                        NewInvoice := not TempPurchLine.IsEmpty();                    end;                PurchHeader."Document Type"::"Return Order":                    if not PurchHeader.Ship then begin                        TempPurchLine.SetFilter("Return Qty. Shipped Not Invd.", '<>0');                        NewInvoice := not TempPurchLine.IsEmpty();                    end;            end;        exit(NewInvoice);    end;    /// <summary>    /// Calculates the invoice discount for the document and updates the document and lines accordingly    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    local procedure CalcInvDiscount(var PurchHeader: Record "Purchase Header")    var        PurchaseHeaderCopy: Record "Purchase Header";        PurchLine: Record "Purchase Line";        IsHandled: Boolean;    begin        if not (PurchSetup."Calc. Inv. Discount" and (PurchHeader.Status <> PurchHeader.Status::Open)) then            exit;        PurchaseHeaderCopy := PurchHeader;        PurchLine.Reset();        PurchLine.SetRange("Document Type", PurchHeader."Document Type");        PurchLine.SetRange("Document No.", PurchHeader."No.");        OnCalcInvDiscountSetFilter(PurchLine, PurchHeader);        PurchLine.FindFirst();        CODEUNIT.Run(CODEUNIT::"Purch.-Calc.Discount", PurchLine);        RefreshTempLines(PurchHeader, TempPurchLineGlobal);        PurchHeader.Get(PurchHeader."Document Type", PurchHeader."No.");        RestorePurchaseHeader(PurchHeader, PurchaseHeaderCopy);        IsHandled := false;        OnCalcInvDiscountOnBeforeDoCommit(PurchHeader, IsHandled);        if not IsHandled then            if not (PreviewMode or SuppressCommit) then                Commit();        OnAfterCalcInvDiscount(PurchHeader, TempPurchLineGlobal);        exit;    end;    /// <summary>    /// Restores postings flags and posting numbers of the document header to their original values    /// </summary>    /// <param name="PurchaseHeader">Return value: The purchase header of the document with the restored values.</param>    /// <param name="PurchaseHeaderCopy">The purchase header of the document with the original values.</param>    local procedure RestorePurchaseHeader(var PurchaseHeader: Record "Purchase Header"; PurchaseHeaderCopy: Record "Purchase Header")    begin        PurchaseHeader.Invoice := PurchaseHeaderCopy.Invoice;        PurchaseHeader.Receive := PurchaseHeaderCopy.Receive;        PurchaseHeader.Ship := PurchaseHeaderCopy.Ship;        PurchaseHeader."Posting No." := PurchaseHeaderCopy."Posting No.";        PurchaseHeader."Receiving No." := PurchaseHeaderCopy."Receiving No.";        PurchaseHeader."Return Shipment No." := PurchaseHeaderCopy."Return Shipment No.";        OnAfterRestorePurchaseHeader(PurchaseHeader, PurchaseHeaderCopy);    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       /// Check for over-receipt is performed    /// </summary>    /// <remarks>    /// Transaction is committed 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 CheckPurchDocument(). Preparation already happened in RunWithCheck() (parent procedure).    /// </remarks>        /// <param name="PurchHeader">Return Value: The purchase header of the document that is being posted, returned with updated values.</param>    local procedure CheckAndUpdate(var PurchHeader: Record "Purchase Header")    var        DummyNoSeries: Record "No. Series";        ModifyHeader: Boolean;        RefreshTempLinesNeeded: Boolean;        IsHandled: Boolean;    begin        OnBeforeCheckAndUpdate(PurchHeader, ModifyHeader);        DocumentIsReadyToBeChecked := true;        CheckPurchDocument(PurchHeader);        if GuiAllowed() and not HideProgressWindow then            InitProgressWindow(PurchHeader);        if PurchHeader.Invoice then begin            CreatePrepmtLines(PurchHeader, true);            CreatePrepaymentLineForCreditMemo(PurchHeader);        end;        DateOrderSeriesUsed := false;        ModifyHeader := UpdatePostingNos(PurchHeader);        if DateOrderSeriesUsed then            SuppressCommit := true;        DropShipOrder := UpdateAssosOrderPostingNos(PurchHeader);        OnBeforePostCommitPurchaseDoc(PurchHeader, GenJnlPostLine, PreviewMode, ModifyHeader, SuppressCommit, TempPurchLineGlobal);        if DateOrderSeriesUsed and (not SuppressCommit) then            Error(SuppressCommitErr, DummyNoSeries.FieldCaption("Date Order"), DummyNoSeries.TableCaption());        if not PreviewMode and ModifyHeader then begin            PurchHeader.Modify();            IsHandled := false;            OnCheckAndUpdateOnBeforeOnBeforeDoCommit(PurchHeader, IsHandled);            if (not IsHandled) and (not SuppressCommit) then                Commit();        end;        OnCheckAndUpdateOnBeforeCalcInvDiscount(          PurchHeader, TempWhseRcptHeader, TempWhseShptHeader, WhseReceive, WhseShip, RefreshTempLinesNeeded);        if RefreshTempLinesNeeded then            RefreshTempLines(PurchHeader, TempPurchLineGlobal);        CalcInvDiscount(PurchHeader);        ReleasePurchDocument(PurchHeader);        HandleArchiveUnpostedOrder(PurchHeader);        CheckICPartnerBlocked(PurchHeader);        SendICDocument(PurchHeader, ModifyHeader);        UpdateHandledICInboxTransaction(PurchHeader);        if PurchHeader.Invoice then            CheckDocumentTotalAmounts(PurchHeader);        LockTables(PurchHeader);        SourceCodeSetup.Get();        SrcCode := SourceCodeSetup.Purchases;        OnCheckAndUpdateOnAfterSetSourceCode(PurchHeader, SourceCodeSetup, SrcCode);        InsertPostedHeaders(PurchHeader);        OnCheckAndUpdateOnAfterInsertPostedHeaders(PurchHeader);        IsHandled := false;        OnCheckAndUpdateOnBeforeUpdateIncomingDocument(PurchHeader, IsHandled);        if not IsHandled then            UpdateIncomingDocument(PurchHeader."Incoming Document Entry No.", PurchHeader."Posting Date", GenJnlLineDocNo);        CheckOverReceipt(PurchHeader);        OnAfterCheckAndUpdate(PurchHeader, SuppressCommit, PreviewMode);    end;    /// <summary>    /// Wrapper procedure for archiving purchase document    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    local procedure HandleArchiveUnpostedOrder(var PurchHeader: Record "Purchase Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnCheckAndUpdateOnBeforeArchiveUnpostedOrder(PurchHeader, PreviewMode, IsHandled);        if IsHandled then            exit;        if PurchHeader.Receive or PurchHeader.Ship then            ArchiveUnpostedOrder(PurchHeader);        OnCheckAndUpdateOnAfterArchiveUnpostedOrder(PurchHeader, Currency, PreviewMode);    end;    /// <summary>    /// Main procedure for checking if document header and lines are valid for posting.    /// Checks for mandatory fields, posting dates, VAT dates, linked documents, posting restrictions, etc.    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    procedure CheckPurchDocument(var PurchHeader: Record "Purchase Header")    var        CheckDimensions: Codeunit "Check Dimensions";        ErrorContextElement: Codeunit "Error Context Element";        CopyAndCheckItemChargeNeeded: Boolean;        IsHandled: Boolean;    begin        if not DocumentIsReadyToBeChecked then            PrepareCheckDocument(PurchHeader);        ErrorMessageMgt.PushContext(ErrorContextElement, PurchHeader.RecordId, 0, CheckPurchHeaderMsg);        CheckMandatoryHeaderFields(PurchHeader);        GetGLSetup();        if GLSetup."Journal Templ. Name Mandatory" then            PurchHeader.TestField("Journal Templ. Name", ErrorInfo.Create());        CheckPostingDate(PurchHeader);        CheckVATDate(PurchHeader);        OnCheckAndUpdateOnBeforeSetPostingFlags(PurchHeader, TempPurchLineGlobal);        if LogErrorMode then            SetLogErrorModePostingFlags(PurchHeader)        else            SetPostingFlags(PurchHeader);        OnCheckAndUpdateOnAfterSetPostingFlags(PurchHeader, TempPurchLineGlobal);        InvtPickPutaway := PurchHeader."Posting from Whse. Ref." <> 0;        PurchHeader."Posting from Whse. Ref." := 0;        OnCheckAndUpdateOnAfterClearPostingFromWhseRef(PurchHeader, InvtPickPutaway);        IsHandled := false;        OnCheckPurchDocumentOnBeforeCheckPurchDim(PurchHeader, TempPurchLineGlobal, IsHandled);        if not IsHandled then            CheckDimensions.CheckPurchDim(PurchHeader, TempPurchLineGlobal);        if PurchHeader.Invoice then            CheckFAPostingPossibility(PurchHeader);        CheckPostRestrictions(PurchHeader);        if ((PurchHeader."Buy-from IC Partner Code" <> '') or (PurchHeader."Pay-to IC Partner Code" <> '')) then            CheckICDocumentDuplicatePosting(PurchHeader);        if PurchHeader.Invoice then            PurchHeader.Invoice := CalcInvoice(PurchHeader);        CopyAndCheckItemChargeNeeded := PurchHeader.Invoice;        OnCheckAndUpdateOnAfterCalcCopyAndCheckItemChargeNeeded(PurchHeader, CopyAndCheckItemChargeNeeded);        if CopyAndCheckItemChargeNeeded then            CopyAndCheckItemCharge(PurchHeader);        OnCheckAndUpdateOnAfterCopyAndCheckItemCharge(PurchHeader);        if PurchHeader.Invoice and not PurchHeader.IsCreditDocType() then            PurchHeader.TestField("Due Date", ErrorInfo.Create());        if PurchHeader.Receive then begin            PurchHeader.Receive := CheckTrackingAndWarehouseForReceive(PurchHeader);            if not InvtPickPutaway then                if CheckIfInvPutawayExists(PurchHeader) then                    Error(ErrorInfo.Create(InvPutAwayExistsErr, true, PurchHeader));        end;        if PurchHeader.Ship then begin            PurchHeader.Ship := CheckTrackingAndWarehouseForShip(PurchHeader);            if not InvtPickPutaway then                if CheckIfInvPickExists() then                    Error(ErrorInfo.Create(InvPickExistsErr, true, PurchHeader));        end;        CheckHeaderPostingType(PurchHeader);        CheckAssociatedOrderLines(PurchHeader);        if PurchHeader.Invoice then            if not SelfBillingInvoiceDocument(PurchHeader) then begin                if PurchSetup."Ext. Doc. No. Mandatory" then                    CheckExtDocNo(PurchHeader);            end else                UpdateVendorInvoiceNoForSelfBilling(PurchHeader);        ErrorMessageMgt.PopContext(ErrorContextElement);        CheckPurchLines(PurchHeader);        OnAfterCheckPurchDoc(PurchHeader, SuppressCommit, WhseShip, WhseReceive, PreviewMode, ErrorMessageMgt);        if not LogErrorMode then            ErrorMessageMgt.Finish(PurchHeader.RecordId);    end;    /// <summary>    /// Wrapper procedure for checking all purchase lines of the document if they are valid for posting.    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    local procedure CheckPurchLines(var PurchHeader: Record "Purchase Header")    var        InventorySetup: Record "Inventory Setup";        ErrorContextElement: Codeunit "Error Context Element";        SequenceNoMgt: Codeunit "Sequence No. Mgt.";        NoOfItemLines: Integer;    begin        if TempPurchLineGlobal.FindSet() then            repeat                ErrorMessageMgt.PushContext(ErrorContextElement, TempPurchLineGlobal.RecordId(), 0, CheckPurchLineMsg);                TestPurchLine(PurchHeader, TempPurchLineGlobal);                if (PurchHeader.Ship or PurchHeader.Receive or PurchHeader.Invoice) and (TempPurchLineGlobal.Type = TempPurchLineGlobal.Type::Item) and (TempPurchLineGlobal."Qty. to Receive" <> 0) then                    NoOfItemLines += 1;            until TempPurchLineGlobal.Next() = 0;        ErrorMessageMgt.PopContext(ErrorContextElement);        if not InventorySetup.UseLegacyPosting() and (NoOfItemLines > 0) then begin            if PurchHeader.Ship or PurchHeader.Receive then                SequenceNoMgt.AllocateSeqNoBuffer(Database::"Item Ledger Entry", NoOfItemLines);            SequenceNoMgt.AllocateSeqNoBuffer(Database::"Value Entry", NoOfItemLines);        end;    end;    /// <summary>    /// Function for checking the total amounts on the header is the same with the total amounts on the lines.    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    procedure CheckDocumentTotalAmounts(var PurchHeader: Record "Purchase Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckDocumentTotalAmounts(PurchHeader, PreviewMode, IsHandled);        if IsHandled then            exit;        GetPurchSetup();        if not PurchSetup.ShouldDocumentTotalAmountsBeChecked(PurchHeader) then            exit;        PurchHeader.CalcFields(Amount, "Amount Including VAT");        if PurchHeader."Amount Including VAT" <> PurchHeader."Doc. Amount Incl. VAT" then            Error(                   ErrorInfo.Create(                       StrSubstNo(CheckTotalAmountPurchLinesErr, PurchHeader.FieldCaption("Doc. Amount Incl. VAT"), PurchHeader."Doc. Amount Incl. VAT", PurchHeader."Amount Including VAT"),                       true,                       PurchHeader));        if (PurchHeader."Amount Including VAT" - PurchHeader.Amount) <> PurchHeader."Doc. Amount VAT" then            Error(                        ErrorInfo.Create(                            StrSubstNo(CheckTotalAmountVATPurchLinesErr, PurchHeader.FieldCaption("Doc. Amount VAT"), PurchHeader."Doc. Amount VAT", PurchHeader."Amount Including VAT" - PurchHeader.Amount),                            true,                            PurchHeader));    end;    /// <summary>    /// Check if external document no. is populated    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    local procedure CheckExtDocNo(PurchaseHeader: Record "Purchase Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckExtDocNo(PurchaseHeader, GenJnlLineDocType, GenJnlLineExtDocNo, IsHandled);        if IsHandled then            exit;        case PurchaseHeader."Document Type" of            PurchaseHeader."Document Type"::Order,              PurchaseHeader."Document Type"::Invoice:                if PurchaseHeader."Vendor Invoice No." = '' then                    Error(                        ErrorInfo.Create(                            StrSubstNo(ExtDocNoNeededErr, PurchaseHeader.FieldCaption("Vendor Invoice No.")),                            true,                            PurchaseHeader));            else                if PurchaseHeader."Vendor Cr. Memo No." = '' then                    Error(                        ErrorInfo.Create(                            StrSubstNo(ExtDocNoNeededErr, PurchaseHeader.FieldCaption("Vendor Cr. Memo No.")),                            true,                            PurchaseHeader));        end;    end;    /// <summary>    /// Prepares document for checking    /// Retrieves relevant setup records and fills the purchase line temporary table for checking    /// </summary>    /// <remarks>    /// Sets the LogErrorMode and DocumentIsReadyToBeChecked to true    /// </remarks>    /// <param name="PurchaseHeader">The purchase header of the document that is being posted.</param>    procedure PrepareCheckDocument(var PurchaseHeader: Record "Purchase Header")    begin        OnBeforePrepareCheckDocument(PurchaseHeader);        GetGLSetup();        GetPurchSetup();        GetInvoicePostingSetup();        GetCurrency(PurchaseHeader."Currency Code");        FillTempLines(PurchaseHeader, TempPurchLineGlobal);        LogErrorMode := true;        DocumentIsReadyToBeChecked := true;    end;    /// <summary>    /// Sets posting flags (Receive, Ship, Invoice) based on the document type    /// </summary>    /// <param name="PurchaseHeader">The purchase header of the document that is being posted.</param>    local procedure SetLogErrorModePostingFlags(var PurchaseHeader: Record "Purchase Header")    begin        PurchaseHeader.Receive := PurchaseHeader."Document Type" in [PurchaseHeader."Document Type"::Order, PurchaseHeader."Document Type"::Invoice];        PurchaseHeader.Ship := PurchaseHeader."Document Type" in [PurchaseHeader."Document Type"::"Return Order", PurchaseHeader."Document Type"::"Credit Memo"];        PurchaseHeader.Invoice := true;    end;    local procedure PostPurchLine(var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var EverythingInvoiced: Boolean; var ICGenJnlLineNo: Integer)    var        PurchInvLine: Record "Purch. Inv. Line";        SearchPurchInvLine: Record "Purch. Inv. Line";        PurchCrMemoLine: Record "Purch. Cr. Memo Line";        SearchPurchCrMemoLine: Record "Purch. Cr. Memo Line";        CostBaseAmount: Decimal;        IsHandled: Boolean;        AmountsOnly: Boolean;    begin        IsHandled := false;        OnBeforePostPurchLine(PurchHeader, PurchLine, IsHandled);        if IsHandled then            exit;        if PurchLine.Type = PurchLine.Type::Item then            CostBaseAmount := PurchLine."Line Amount";        UpdateQtyPerUnitOfMeasure(PurchLine);        UpdatePurchLineBeforePost(PurchHeader, PurchLine);        if PurchLine."Qty. to Invoice" + PurchLine."Quantity Invoiced" <> PurchLine.Quantity then            EverythingInvoiced := false;        AmountsOnly := false;        OnPostPurchLineOnAfterSetEverythingInvoiced(PurchLine, EverythingInvoiced, PurchHeader, TempVATAmountLine, TempVATAmountLineRemainder, AmountsOnly);        if (PurchLine.Quantity <> 0) or AmountsOnly then begin            if not AmountsOnly then                PurchLine.TestField("No.");            PurchLine.TestField(Type);            IsHandled := false;            OnPostPurchLineOnBeforeTestGeneralPostingGroups(PurchLine, IsHandled);            if not IsHandled then                if not ApplicationAreaMgmt.IsSalesTaxEnabled() then begin                    PurchLine.TestField("Gen. Bus. Posting Group");                    PurchLine.TestField("Gen. Prod. Posting Group");                end;            IsHandled := false;            OnPostPurchLineOnBeforeDivideAmount(PurchHeader, PurchLine, TempVATAmountLine, TempVATAmountLineRemainder, IsHandled);            if not IsHandled then                DivideAmount(PurchHeader, PurchLine, 1, PurchLine."Qty. to Invoice", TempVATAmountLine, TempVATAmountLineRemainder);        end else            if not AmountsOnly then                PurchLine.TestField(Amount, 0);        CheckItemReservDisruption(PurchLine);        OnPostPurchLineOnBeforeRoundAmount(PurchHeader, PurchLine, PurchInvHeader, PurchCrMemoHeader, SrcCode);        RoundAmount(PurchHeader, PurchLine, PurchLine."Qty. to Invoice");        if PurchLine.IsCreditDocType() then begin            ReverseAmount(PurchLine);            ReverseAmount(PurchLineACY);        end;        RemQtyToBeInvoiced := PurchLine."Qty. to Invoice";        RemQtyToBeInvoicedBase := PurchLine."Qty. to Invoice (Base)";        InvoicePostingInterface.CheckCreditLine(PurchHeader, PurchLine);        MatchedOrderLineMgmt.CheckMatchedOrderLine(PurchHeader, PurchLine);        PostItemTrackingLine(PurchHeader, PurchLine);        OnPostPurchLineOnBeforePostByType(PurchHeader, PurchInvHeader, PurchCrMemoHeader, PurchLine, PurchLineACY, SrcCode);        case PurchLine.Type of            PurchLine.Type::"G/L Account":                PostGLAccICLine(PurchHeader, PurchLine, ICGenJnlLineNo);            PurchLine.Type::Item:                PostItemLine(PurchHeader, PurchLine, TempDropShptPostBuffer);            PurchLine.Type::Resource:                PostResourceLine(PurchHeader, PurchLine);            PurchLine.Type::"Charge (Item)":                PostItemChargeLine(PurchHeader, PurchLine);            else                OnPostPurchLineOnTypeCaseElse(PurchHeader, PurchLine, PurchInvHeader, PurchCrMemoHeader, SrcCode, GenJnlPostLine, TempDropShptPostBuffer);        end;        OnPostPurchLineOnAfterPostByType(PurchHeader, PurchLine, GenJnlPostLine, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlLineDocType, SrcCode);        if (PurchLine.Type <> PurchLine.Type::" ") and (PurchLine."Qty. to Invoice" <> 0) then begin            AdjustPrepmtAmountLCY(PurchHeader, PurchLine);            InvoicePostingInterface.PrepareLine(PurchHeader, PurchLine, PurchLineACY);        end;        IsHandled := false;        OnPostPurchLineOnBeforeInsertReceiptLine(            PurchHeader, PurchLine, IsHandled, PurchRcptHeader, RoundingLineInserted, CostBaseAmount, xPurchLine, ReturnShptHeader, TempTrackingSpecification, ItemLedgShptEntryNo, SrcCode, PreviewMode, WhseRcptHeader, WhseReceive, WhseShip, GenJnlPostLine, GenJnlLineDocNo);        if not IsHandled then            if (PurchRcptHeader."No." <> '') and not PurchLine.IsMatchedToReceiptOrOrder() and               not RoundingLineInserted and not PurchLine."Prepayment Line"            then                InsertReceiptLine(PurchRcptHeader, PurchLine, CostBaseAmount);        IsHandled := false;        OnPostPurchLineOnBeforeInsertReturnShipmentLine(PurchHeader, PurchLine, IsHandled, ReturnShptHeader, TempPurchLineGlobal, RoundingLineInserted, xPurchLine, PurchRcptHeader);        if not IsHandled then            if (ReturnShptHeader."No." <> '') and (PurchLine."Return Shipment No." = '') and               not RoundingLineInserted            then                InsertReturnShipmentLine(ReturnShptHeader, PurchLine, CostBaseAmount);        OnPostPurchLineOnAfterInsertReturnShipmentLine(PurchHeader, PurchLine, ReturnShptHeader, TempPurchLineGlobal, RoundingLineInserted, xPurchLine, PurchCrMemoHeader);        IsHandled := false;        if PurchHeader.Invoice then            if PurchLine."Document Type" in [PurchLine."Document Type"::Order, PurchLine."Document Type"::Invoice] then begin                OnPostPurchLineOnBeforeInsertInvoiceLine(PurchHeader, PurchLine, IsHandled, PurchInvLine);                if not IsHandled then begin                    PurchInvLine.InitFromPurchLine(PurchInvHeader, xPurchLine);                    ItemJnlPostLine.CollectValueEntryRelation(TempValueEntryRelation, CopyStr(PurchInvLine.RowID1(), 1, 100));                    SetInvoiceOrderNo(PurchLine, PurchInvLine);                    OnBeforePurchInvLineInsert(PurchInvLine, PurchInvHeader, PurchLine, SuppressCommit, xPurchLine);                    if not IsNullGuid(PurchLine.SystemId) then begin                        SearchPurchInvLine.SetRange(SystemId, PurchLine.SystemId);                        if SearchPurchInvLine.IsEmpty() then begin                            PurchInvLine.SystemId := PurchLine.SystemId;                            PurchInvLine.Insert(true, true);                        end else begin                            Session.LogMessage('0000DD4', SameIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', PurchLinePostCategoryTok);                            PurchInvLine.Insert(true);                        end;                    end else begin                        PurchInvLine.Insert(true);                        Session.LogMessage('0000DDA', EmptyIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', PurchLinePostCategoryTok);                    end;                    MatchedOrderLineMgmt.InsertPostedMatchedOrderLines(PurchInvLine, PurchLine);                    OnAfterPurchInvLineInsert(                        PurchInvLine, PurchInvHeader, PurchLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit,                        PurchHeader, PurchRcptHeader, TempWhseRcptHeader, ItemJnlPostLine);                    InvoicePostingInterface.CreatePostedDeferralSchedule(                        xPurchLine, PurchInvLine.GetDocumentType(),                        PurchInvHeader."No.", PurchInvLine."Line No.", PurchInvHeader."Posting Date");                    OnPostPurchLineOnAfterCreatePostedDeferralScheduleFromPurchDoc(                        PurchInvLine, PurchInvHeader, PurchLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit, xPurchLine);                end;            end else begin // Credit Memo                OnPostPurchLineOnBeforeInsertCrMemoLine(PurchHeader, PurchLine, IsHandled, PurchCrMemoLine, xPurchLine);                if not IsHandled then begin                    PurchCrMemoLine.InitFromPurchLine(PurchCrMemoHeader, xPurchLine);                    ItemJnlPostLine.CollectValueEntryRelation(TempValueEntryRelation, CopyStr(PurchCrMemoLine.RowID1(), 1, 100));                    SetCreditMemoOrderNo(PurchLine, PurchCrMemoLine);                    OnBeforePurchCrMemoLineInsert(PurchCrMemoLine, PurchCrMemoHeader, PurchLine, SuppressCommit, xPurchLine);                    if not IsNullGuid(PurchLine.SystemId) then begin                        SearchPurchCrMemoLine.SetRange(SystemId, PurchLine.SystemId);                        if SearchPurchCrMemoLine.IsEmpty() then begin                            PurchCrMemoLine.SystemId := PurchLine.SystemId;                            PurchCrMemoLine.Insert(true, true);                        end else begin                            Session.LogMessage('0000DD5', SameIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', PurchLinePostCategoryTok);                            PurchCrMemoLine.Insert(true);                        end;                    end else begin                        PurchCrMemoLine.Insert(true);                        Session.LogMessage('0000DDB', EmptyIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', PurchLinePostCategoryTok);                    end;                    OnAfterPurchCrMemoLineInsert(PurchCrMemoLine, PurchCrMemoHeader, PurchLine, SuppressCommit, PurchHeader, GenJnlLineDocNo, RoundingLineInserted, ItemJnlPostLine);                    InvoicePostingInterface.CreatePostedDeferralSchedule(                        xPurchLine, PurchCrMemoLine.GetDocumentType(),                        PurchCrMemoHeader."No.", PurchCrMemoLine."Line No.", PurchCrMemoHeader."Posting Date");                    OnPostPurchLineOnAfterCreatePostedDeferralScheduleFromPurchDocCrMemo(                        PurchCrMemoLine, PurchCrMemoHeader, PurchLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit, xPurchLine);                end;            end;        OnAfterPostPurchLine(            PurchHeader, PurchLine, SuppressCommit, PurchInvLine, PurchCrMemoLine, PurchInvHeader, PurchCrMemoHeader, PurchLineACY,            GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, xPurchLine);    end;    local procedure SetInvoiceOrderNo(PurchaseLine: Record "Purchase Line"; var PurchInvLine: Record "Purch. Inv. Line")    var        PurchRcptLine: Record "Purch. Rcpt. Line";    begin        if PurchaseLine."Document Type" = PurchaseLine."Document Type"::Order then begin            PurchInvLine."Order No." := PurchaseLine."Document No.";            PurchInvLine."Order Line No." := PurchaseLine."Line No.";        end else            if PurchRcptLine.Get(PurchaseLine."Receipt No.", PurchaseLine."Receipt Line No.") then begin                PurchInvLine."Order No." := PurchRcptLine."Order No.";                PurchInvLine."Order Line No." := PurchRcptLine."Order Line No.";            end;    end;    local procedure SetCreditMemoOrderNo(PurchaseLine: Record "Purchase Line"; var PurchCrMemoLine: Record "Purch. Cr. Memo Line")    var        ReturnShipmentLine: Record "Return Shipment Line";    begin        if PurchaseLine."Document Type" = PurchaseLine."Document Type"::"Return Order" then begin            PurchCrMemoLine."Order No." := PurchaseLine."Document No.";            PurchCrMemoLine."Order Line No." := PurchaseLine."Line No.";        end else            if ReturnShipmentLine.Get(PurchaseLine."Return Shipment No.", PurchaseLine."Return Shipment Line No.") then begin                PurchCrMemoLine."Order No." := ReturnShipmentLine."Return Order No.";                PurchCrMemoLine."Order Line No." := ReturnShipmentLine."Return Order Line No.";            end;    end;    local procedure PostInvoice(var PurchHeader: Record "Purchase Header")    var        TotalAmount: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostInvoice(PurchHeader, PreviewMode, SuppressCommit, GenJnlPostLine, IsHandled, Window, HideProgressWindow, TotalPurchLine, TotalPurchLineLCY, InvoicePostingInterface, InvoicePostingParameters, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlLineDocType, SrcCode);        if IsHandled then            exit;        // Post purchase and VAT to G/L entries from buffer        GetInvoicePostingParameters();        InvoicePostingInterface.SetParameters(InvoicePostingParameters);        InvoicePostingInterface.SetTotalLines(TotalPurchLine, TotalPurchLineLCY);        InvoicePostingInterface.PostLines(PurchHeader, GenJnlPostLine, Window, TotalAmount);        OnPostInvoiceOnAfterPostLines(PurchHeader, SrcCode, GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlPostLine, TotalPurchLine, TotalPurchLineLCY, TempPurchLineGlobal, TotalAmount);        // Check External Document number        if PurchSetup."Ext. Doc. No. Mandatory" or (GenJnlLineExtDocNo <> '') then            CheckExternalDocumentNumber(VendLedgEntry, PurchHeader);        // Post vendor entries        if GuiAllowed() and not HideProgressWindow then            Window.Update(4, 1);        InvoicePostingInterface.SetParameters(InvoicePostingParameters);        InvoicePostingInterface.SetTotalLines(TotalPurchLine, TotalPurchLineLCY);        InvoicePostingInterface.PostLedgerEntry(PurchHeader, GenJnlPostLine);        UpdatePurchaseHeader(VendLedgEntry, PurchHeader);        // Balancing account        if PurchHeader."Bal. Account No." <> '' then begin            if GuiAllowed() and not HideProgressWindow then                Window.Update(5, 1);            OnPostInvoiceOnBeforePostBalancingEntry(PurchHeader, LineCount);            InvoicePostingInterface.PostBalancingEntry(PurchHeader, GenJnlPostLine);        end;        OnAfterPostInvoice(PurchHeader, GenJnlPostLine, TotalPurchLine, TotalPurchLineLCY, SuppressCommit, VendLedgEntry);    end;    local procedure PostGLAccICLine(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; var ICGenJnlLineNo: Integer)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostGLAccICLine(PurchHeader, PurchLine, ICGenJnlLineNo, IsHandled);        if IsHandled then            exit;        if (PurchLine."No." <> '') and not PurchLine."System-Created Entry" then begin            CheckGLAccDirectPosting(PurchLine);            if (PurchLine."Job No." <> '') and (PurchLine."Qty. to Invoice" <> 0) then begin                IsHandled := false;                OnPostGLAccICLineOnBeforeCreateJobPurchLine(PurchHeader, PurchLine, IsHandled);                if not IsHandled then begin                    CreateJobPurchLine(JobPurchLine, PurchLine, PurchHeader."Prices Including VAT");                    OnPostGLAccICLineOnAfterCreateJobPurchLine(PurchHeader);                    InvoicePostingInterface.PrepareJobLine(PurchHeader, JobPurchLine, PurchLineACY);                end;            end;            OnPostGLAccICLineOnBeforeCheckAndInsertICGenJnlLine(PurchHeader, PurchLine, xPurchLine, ICGenJnlLineNo);            if (PurchLine."IC Partner Code" <> '') and PurchHeader.Invoice then                InsertICGenJnlLine(PurchHeader, xPurchLine, ICGenJnlLineNo);            OnAfterPostAccICLine(PurchLine, SuppressCommit, PurchHeader, PurchInvHeader, PurchCrMemoHeader);        end;    end;    local procedure CheckGLAccDirectPosting(PurchaseLine: Record "Purchase Line")    var        GLAccount: Record "G/L Account";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckGLAccDirectPosting(PurchaseLine, IsHandled);        if IsHandled then            exit;        GLAccount.Get(PurchaseLine."No.");        GLAccount.TestField("Direct Posting");    end;    local procedure PostItemLine(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    var        DummyTrackingSpecification: Record "Tracking Specification";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemLine(PurchHeader, PurchLine, PurchRcptHeader, RemQtyToBeInvoiced, TempPurchLineGlobal, TempDropShptPostBuffer, RemQtyToBeInvoicedBase, IsHandled);        if IsHandled then            exit;        ItemLedgShptEntryNo := 0;        if RemQtyToBeInvoiced <> 0 then            ItemLedgShptEntryNo :=              PostItemJnlLine(                PurchHeader, PurchLine,                RemQtyToBeInvoiced, RemQtyToBeInvoicedBase,                RemQtyToBeInvoiced, RemQtyToBeInvoicedBase,                0, '', DummyTrackingSpecification);        OnPostItemLineOnBeforePostShipReceive(PurchHeader, PurchLine, TempDropShptPostBuffer, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase);        if PurchHeader.IsCreditDocType() then begin            if Abs(PurchLine."Return Qty. to Ship") > Abs(RemQtyToBeInvoiced) then                ItemLedgShptEntryNo :=                  PostItemJnlLine(                    PurchHeader, PurchLine,                    PurchLine."Return Qty. to Ship" - RemQtyToBeInvoiced,                    PurchLine."Return Qty. to Ship (Base)" - RemQtyToBeInvoicedBase,                    0, 0, 0, '', DummyTrackingSpecification);        end else begin            if Abs(PurchLine."Qty. to Receive") > Abs(RemQtyToBeInvoiced) then                ItemLedgShptEntryNo :=                  PostItemJnlLine(                    PurchHeader, PurchLine,                    PurchLine."Qty. to Receive" - RemQtyToBeInvoiced,                    PurchLine."Qty. to Receive (Base)" - RemQtyToBeInvoicedBase,                    0, 0, 0, '', DummyTrackingSpecification);            ProcessAssocItemJnlLine(PurchHeader, PurchLine, TempDropShptPostBuffer);        end;        OnAfterPostItemLine(PurchLine, SuppressCommit, PurchHeader, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, TempDropShptPostBuffer);    end;    local procedure ProcessAssocItemJnlLine(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeProcessAssocItemJnlLine(PurchLine, IsHandled, TempDropShptPostBuffer, TempTrackingSpecification, ItemLedgShptEntryNo, ItemJnlPostLine, SrcCode);        if IsHandled then            exit;        if (PurchLine."Qty. to Receive" <> 0) and (PurchLine."Sales Order Line No." <> 0) then begin            TempDropShptPostBuffer."Order No." := PurchLine."Sales Order No.";            TempDropShptPostBuffer."Order Line No." := PurchLine."Sales Order Line No.";            TempDropShptPostBuffer.Quantity := PurchLine."Qty. to Receive";            TempDropShptPostBuffer."Quantity (Base)" := PurchLine."Qty. to Receive (Base)";            OnProcessAssocItemJnlLineOnAfterInitTempDropShptPostBuffer(PurchLine, TempDropShptPostBuffer);            TempDropShptPostBuffer."Item Shpt. Entry No." :=              PostAssocItemJnlLine(PurchHeader, PurchLine, TempDropShptPostBuffer.Quantity, TempDropShptPostBuffer."Quantity (Base)");            OnBeforeTempDropShptPostBufferInsert(TempDropShptPostBuffer, PurchLine, ItemLedgShptEntryNo);            TempDropShptPostBuffer.Insert();        end;        OnAfterProcessAssocItemJnlLine(PurchLine, TempDropShptPostBuffer);    end;    local procedure PostItemChargeLine(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line")    var        PurchaseLineBackup: Record "Purchase Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemChargeLineProcedure(PurchHeader, PurchLine, IsHandled);        if IsHandled then            exit;        if not IsItemChargeLineWithQuantityToInvoice(PurchHeader, PurchLine) then            exit;        ItemJnlRollRndg := true;        PurchaseLineBackup.Copy(PurchLine);        if FindTempItemChargeAssgntPurch(PurchaseLineBackup."Line No.") then            repeat                OnPostItemChargeLineOnBeforePostItemCharge(TempItemChargeAssgntPurch, PurchHeader, PurchaseLineBackup, GenJnlLineDocNo);                case TempItemChargeAssgntPurch."Applies-to Doc. Type" of                    TempItemChargeAssgntPurch."Applies-to Doc. Type"::Receipt:                        begin                            PostItemChargePerRcpt(PurchHeader, PurchaseLineBackup);                            TempItemChargeAssgntPurch.Mark(true);                        end;                    TempItemChargeAssgntPurch."Applies-to Doc. Type"::"Transfer Receipt":                        begin                            PostItemChargePerTransfer(PurchHeader, PurchaseLineBackup);                            TempItemChargeAssgntPurch.Mark(true);                        end;                    TempItemChargeAssgntPurch."Applies-to Doc. Type"::"Return Shipment":                        begin                            PostItemChargePerRetShpt(PurchHeader, PurchaseLineBackup);                            TempItemChargeAssgntPurch.Mark(true);                        end;                    TempItemChargeAssgntPurch."Applies-to Doc. Type"::"Sales Shipment":                        begin                            PostItemChargePerSalesShpt(PurchHeader, PurchaseLineBackup);                            TempItemChargeAssgntPurch.Mark(true);                        end;                    TempItemChargeAssgntPurch."Applies-to Doc. Type"::"Return Receipt":                        begin                            PostItemChargePerRetRcpt(PurchHeader, PurchaseLineBackup);                            TempItemChargeAssgntPurch.Mark(true);                        end;                    TempItemChargeAssgntPurch."Applies-to Doc. Type"::Order,                  TempItemChargeAssgntPurch."Applies-to Doc. Type"::Invoice,                  TempItemChargeAssgntPurch."Applies-to Doc. Type"::"Return Order",                  TempItemChargeAssgntPurch."Applies-to Doc. Type"::"Credit Memo":                        CheckItemCharge(TempItemChargeAssgntPurch);                end;                OnPostItemChargeLineOnAfterPostItemCharge(TempItemChargeAssgntPurch, PurchHeader, PurchaseLineBackup, PurchLine);            until TempItemChargeAssgntPurch.Next() = 0;    end;    local procedure IsItemChargeLineWithQuantityToInvoice(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line") Result: Boolean    var        IsHandled: Boolean;    begin        OnBeforeIsItemChargeLineWithQuantityToInvoice(PurchHeader, PurchLine, Result, IsHandled);        if IsHandled then            exit;        exit(PurchHeader.Invoice and (PurchLine."Qty. to Invoice" <> 0));    end;    local procedure PostItemTrackingLine(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line")    var        TempTrackingSpecification: Record "Tracking Specification" temporary;        TrackingSpecificationExists: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemTrackingLineOnPostPurchLine(PurchHeader, PurchLine, IsHandled, TempTrackingSpecification, PurchInvHeader, PurchCrMemoHeader, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase);        if IsHandled then            exit;        if PurchLine."Prepayment Line" then            exit;        RetrieveInvoiceTrackingSpecificationIfExists(PurchHeader, PurchLine, TempTrackingSpecification, TrackingSpecificationExists);        PostItemTracking(PurchHeader, PurchLine, TempTrackingSpecification, TrackingSpecificationExists);        if TrackingSpecificationExists then            SaveInvoiceSpecification(TempTrackingSpecification);        OnAfterPostItemTrackingLine(PurchHeader, PurchLine, WhseReceive, WhseShip, InvtPickPutaway);    end;    local procedure RetrieveInvoiceTrackingSpecificationIfExists(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean)    begin        if PurchaseHeader.Invoice then            if PurchaseLine."Qty. to Invoice" = 0 then                TrackingSpecificationExists := false            else                TrackingSpecificationExists :=                  PurchLineReserve.RetrieveInvoiceSpecification(PurchaseLine, TempTrackingSpecification);        OnAfterRetrieveInvoiceTrackingSpecificationIfExists(PurchaseHeader, PurchaseLine, TempTrackingSpecification, TrackingSpecificationExists);    end;    /// <summary>    /// Creates and posts item journal line based on the purchase document information    /// If purchase line is associated with the production order item journal line is update with order information    /// When advanced warehousing is enabled for the location warehouse journal line is created and posted    /// If purchase line is associated with a job, job consumption journal entry is posted    /// When invoicing item purchase line, item charge assignments are posted    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    /// <param name="QtyToBeReceived">Purchase Line Quantity to be received</param>    /// <param name="QtyToBeReceivedBase">Purchase Line Quantity to be received in base unit of measure</param>    /// <param name="QtyToBeInvoiced">Purchase Line Quantity to be invoiced</param>    /// <param name="QtyToBeInvoicedBase">Purchase Line Quantity to be invoiced in base unit of measure</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 purchase line. This parameter is exposed through events, but isn't directly used in the procedure</param>    /// <returns>The Item Shipment Entry No. assigned to the Item Journal Line.</returns>    procedure PostItemJnlLine(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; QtyToBeReceived: Decimal; QtyToBeReceivedBase: Decimal; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; ItemLedgShptEntryNo: Integer; ItemChargeNo: Code[20]; TrackingSpecification: Record "Tracking Specification") Result: Integer    var        ItemJnlLine: Record "Item Journal Line";        OriginalItemJnlLine: Record "Item Journal Line";        TempWhseJnlLine: Record "Warehouse Journal Line" temporary;        TempWhseTrackingSpecification: Record "Tracking Specification" temporary;        TempTrackingSpecificationChargeAssmt: Record "Tracking Specification" temporary;        TempReservationEntry: Record "Reservation Entry" temporary;        PostWhseJnlLine: Boolean;        CheckApplToItemEntry: Boolean;        PostJobConsumptionBeforePurch: Boolean;        IsHandled: Boolean;    begin        ClearRemAmt(PurchHeader);        IsHandled := false;        OnBeforePostItemJnlLine(          PurchHeader, PurchLine, QtyToBeReceived, QtyToBeReceivedBase, QtyToBeInvoiced, QtyToBeInvoicedBase,          ItemLedgShptEntryNo, ItemChargeNo, TrackingSpecification, SuppressCommit, IsHandled, ItemJnlPostLine, Result, WhseRcptHeader);        if IsHandled then            exit(Result);        ItemJnlLine.Init();        ItemJnlLine.CopyFromPurchHeader(PurchHeader);        ItemJnlLine.CopyFromPurchLine(PurchLine);        IsHandled := false;        OnPostItemJnlLineOnBeforePostItemJnlLineCopyDocumentFields(ItemJnlLine, PurchHeader, PurchLine, QtyToBeInvoiced, QtyToBeReceived, WhseReceive, WhseShip, InvtPickPutaway, IsHandled);        if not IsHandled then            PostItemJnlLineCopyDocumentFields(ItemJnlLine, PurchHeader, PurchLine, QtyToBeInvoiced, QtyToBeReceived);        if QtyToBeInvoiced <> 0 then            ItemJnlLine."Invoice No." := GenJnlLineDocNo;        ItemJnlLine.CopyTrackingFromSpec(TrackingSpecification);        ItemJnlLine."Item Shpt. Entry No." := ItemLedgShptEntryNo;        ItemJnlLine.Quantity := QtyToBeReceived;        ItemJnlLine."Quantity (Base)" := QtyToBeReceivedBase;        ItemJnlLine."Invoiced Quantity" := QtyToBeInvoiced;        ItemJnlLine."Invoiced Qty. (Base)" := QtyToBeInvoicedBase;        if ItemChargeNo <> '' then begin            ItemJnlLine."Item Charge No." := ItemChargeNo;            PurchLine."Qty. to Invoice" := QtyToBeInvoiced;            OnPostItemJnlLineOnAfterCopyItemCharge(ItemJnlLine, TempItemChargeAssgntPurch);        end;        OnPostItemJnlLineOnBeforeInitAmount(ItemJnlLine, PurchHeader, PurchLine);        if QtyToBeInvoiced <> 0 then            CalcItemJnlLineToBeInvoicedAmounts(ItemJnlLine, PurchHeader, PurchLine, QtyToBeInvoiced, QtyToBeInvoicedBase)        else            CalcItemJnlLineToBeReceivedAmounts(ItemJnlLine, PurchHeader, PurchLine, QtyToBeReceived);        OnPostItemJnlLineOnAfterPrepareItemJnlLine(            ItemJnlLine, PurchLine, PurchHeader, PreviewMode, GenJnlLineDocNo, TrackingSpecification, QtyToBeReceived, QtyToBeInvoiced);        OnPostItemJnlLineOnCopyProdOrder(ItemJnlLine, PurchLine, PurchRcptHeader, QtyToBeReceived, QtyToBeInvoiced, SuppressCommit);        CheckApplToItemEntry := SetCheckApplToItemEntry(PurchLine, PurchHeader, ItemJnlLine);        IsHandled := false;        OnPostItemJnlLineOnAfterSetCheckApplToItemEntry(PurchLine, IsHandled);        if not IsHandled then begin            PostWhseJnlLine := ShouldPostWhseJnlLine(PurchLine, ItemJnlLine, TempWhseJnlLine);            if QtyToBeReceivedBase <> 0 then begin                if PurchLine.IsCreditDocType() then                    PurchLineReserve.TransferPurchLineToItemJnlLine(                      PurchLine, ItemJnlLine, -QtyToBeReceivedBase, CheckApplToItemEntry)                else                    PurchLineReserve.TransferPurchLineToItemJnlLine(                      PurchLine, ItemJnlLine, QtyToBeReceivedBase, CheckApplToItemEntry);                if CheckApplToItemEntry and PurchLine.IsInventoriableItem() then                    PurchLine.TestField("Appl.-to Item Entry");            end;            CollectPurchaseLineReservEntries(TempReservationEntry, ItemJnlLine);            OriginalItemJnlLine := ItemJnlLine;            TempHandlingSpecification.Reset();            TempHandlingSpecification.DeleteAll();            IsHandled := false;            OnBeforeItemJnlPostLine(ItemJnlLine, PurchLine, PurchHeader, SuppressCommit, IsHandled, WhseRcptHeader, WhseShptHeader, TempItemChargeAssgntPurch, TempWhseRcptHeader, PurchInvHeader, PurchCrMemoHeader);            if not IsHandled then                if PurchLine."Job No." <> '' then begin                    PostJobConsumptionBeforePurch := ItemJnlLine.IsPurchaseReturn();                    if PostJobConsumptionBeforePurch then                        PostItemJnlLineJobConsumption(                          PurchHeader, PurchLine, OriginalItemJnlLine, TempReservationEntry, QtyToBeInvoiced, QtyToBeReceived,                          TempHandlingSpecification, 0);                end;            IsHandled := false;            OnPostItemJnlLineOnBeforeItemJnlPostLineRunWithCheck(ItemJnlLine, PurchLine, DropShipOrder, PurchHeader, WhseReceive, QtyToBeReceived, QtyToBeReceivedBase, QtyToBeInvoiced, QtyToBeInvoicedBase, IsHandled);            if not IsHandled then                RunItemJnlPostLine(ItemJnlLine);            OnPostItemJnlLineOnAfterItemJnlPostLineRunWithCheck(ItemJnlLine, PurchLine, PurchHeader, QtyToBeReceived, WhseReceive, TempWhseRcptHeader, QtyToBeReceivedBase);            if not ItemJnlLine.Subcontracting then                PostItemJnlLineTracking(                  PurchLine, TempWhseTrackingSpecification, TempTrackingSpecificationChargeAssmt, PostWhseJnlLine, QtyToBeInvoiced);            OnBeforePostItemJnlLineJobConsumption(              ItemJnlLine, PurchLine, PurchInvHeader, PurchCrMemoHeader, QtyToBeInvoiced, QtyToBeInvoicedBase, SrcCode, PostJobConsumptionBeforePurch);            if PurchLine."Job No." <> '' then                if not PostJobConsumptionBeforePurch then                    PostItemJnlLineJobConsumption(                      PurchHeader, PurchLine, OriginalItemJnlLine, TempReservationEntry, QtyToBeInvoiced, QtyToBeReceived,                      TempHandlingSpecification, ItemJnlLine."Item Shpt. Entry No.");            OnPostItemJnlLineOnAfterPostItemJnlLineJobConsumption(ItemJnlLine, PurchHeader, PurchLine, OriginalItemJnlLine, TempReservationEntry, TempHandlingSpecification, QtyToBeInvoiced, QtyToBeReceived, PostJobConsumptionBeforePurch, ItemJnlPostLine, TempWhseTrackingSpecification);            if PostWhseJnlLine then begin                OnPostItemJnlLineOnBeforePostWhseJnlLine(TempHandlingSpecification, TempWhseJnlLine, ItemJnlLine);                PostItemJnlLineWhseLine(TempWhseJnlLine, TempWhseTrackingSpecification, PurchLine, PostJobConsumptionBeforePurch);                OnAfterPostWhseJnlLine(PurchLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit);            end;            if (PurchLine.Type = PurchLine.Type::Item) and PurchHeader.Invoice then                PostItemJnlLineItemCharges(                  PurchHeader, PurchLine, OriginalItemJnlLine, ItemJnlLine."Item Shpt. Entry No.", TempTrackingSpecificationChargeAssmt);        end;        OnAfterPostItemJnlLine(ItemJnlLine, PurchLine, PurchHeader, ItemJnlPostLine, WhseJnlPostLine, WhseReceive, WhseShip, WhseRcptHeader, WhseShptHeader);        ItemJnlPostLine.RunOnPublishPostingInventoryToGL();        exit(ItemJnlLine."Item Shpt. Entry No.");    end;    local procedure CalcItemJnlLineToBeInvoicedAmounts(var ItemJnlLine: Record "Item Journal Line"; var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    var        Factor: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcItemJnlLineToBeInvoicedAmounts(ItemJnlLine, PurchaseHeader, PurchaseLine, QtyToBeInvoiced, QtyToBeInvoicedBase, RemAmt, RemDiscAmt, IsHandled);        if IsHandled then            exit;        if (QtyToBeInvoicedBase <> 0) and (PurchaseLine.Type = PurchaseLine.Type::Item) then            Factor := QtyToBeInvoicedBase / PurchaseLine."Qty. to Invoice (Base)"        else            Factor := QtyToBeInvoiced / PurchaseLine."Qty. to Invoice";        OnPostItemJnlLineOnAfterSetFactor(PurchaseLine, Factor, GenJnlLineExtDocNo, ItemJnlLine);        ItemJnlLine.Amount := PurchaseLine.Amount * Factor + RemAmt;        if not PurchaseLine."Item Charge Has Non.Ded. VAT" then            ItemJnlLine.Amount += NonDeductibleVAT.GetNonDeductibleVATAmountForItemCost(PurchaseLine) * Factor;        if PurchaseHeader."Prices Including VAT" then            ItemJnlLine."Discount Amount" :=                (PurchaseLine."Line Discount Amount" + PurchaseLine."Inv. Discount Amount") /                (1 + PurchaseLine."VAT %" / 100) * Factor + RemDiscAmt        else            ItemJnlLine."Discount Amount" :=                (PurchaseLine."Line Discount Amount" + PurchaseLine."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 CalcItemJnlLineToBeReceivedAmounts(var ItemJnlLine: Record "Item Journal Line"; var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; QtyToBeReceived: Decimal)    var        TotalReceivedQty: Decimal;        TotalAmount: Decimal;        PrevAmount: Decimal;        UnitAmount: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcItemJnlLineToBeReceivedAmounts(ItemJnlLine, PurchaseHeader, PurchaseLine, QtyToBeReceived, RemAmt, IsHandled);        if IsHandled then            exit;        UnitAmount := PurchaseLine."Direct Unit Cost" * (1 - PurchaseLine."Line Discount %" / 100);        if PurchaseHeader."Prices Including VAT" then            UnitAmount := UnitAmount / (1 + PurchaseLine."VAT %" / 100);        GetInventorySetup();        if InventorySetup."Automatic Cost Posting" and InventorySetup."Expected Cost Posting to G/L" then begin            TotalReceivedQty := PurchaseLine."Quantity Received" + QtyToBeReceived;            TotalAmount := TotalReceivedQty * UnitAmount;            PrevAmount := PurchaseLine."Quantity Received" * UnitAmount;            ItemJnlLine.Amount := (TotalAmount - Round(PrevAmount)) + RemAmt;        end else            ItemJnlLine.Amount := (QtyToBeReceived * UnitAmount) + RemAmt;        RemAmt := ItemJnlLine.Amount - Round(ItemJnlLine.Amount);        if PurchaseHeader."Currency Code" <> '' then            ItemJnlLine.Amount :=                Round(                CurrExchRate.ExchangeAmtFCYToLCY(                    PurchaseHeader."Posting Date", PurchaseHeader."Currency Code",                    ItemJnlLine.Amount, PurchaseHeader."Currency Factor"))        else            ItemJnlLine.Amount := Round(ItemJnlLine.Amount);    end;    local procedure ClearRemAmt(PurchHeader: Record "Purchase Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeClearRemAmt(PurchHeader, IsHandled, ItemJnlRollRndg, RemAmt, RemDiscAmt);        if IsHandled then            exit;        if not ItemJnlRollRndg then begin            RemAmt := 0;            RemDiscAmt := 0;        end;    end;    local procedure PostItemJnlLineCopyDocumentFields(var ItemJnlLine: Record "Item Journal Line"; PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; QtyToBeInvoiced: Decimal; QtyToBeReceived: Decimal)    begin        OnPostItemJnlLineOnBeforeCopyDocumentFields(ItemJnlLine, PurchHeader, PurchLine, WhseReceive, WhseShip, InvtPickPutaway);        if QtyToBeReceived = 0 then            if PurchLine.IsCreditDocType() then                ItemJnlLine.CopyDocumentFields(                  ItemJnlLine."Document Type"::"Purchase Credit Memo", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, PurchHeader."Posting No. Series")            else                ItemJnlLine.CopyDocumentFields(                  ItemJnlLine."Document Type"::"Purchase Invoice", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, PurchHeader."Posting No. Series")        else begin            if PurchLine.IsCreditDocType() then                ItemJnlLine.CopyDocumentFields(                  ItemJnlLine."Document Type"::"Purchase Return Shipment",                  ReturnShptHeader."No.", ReturnShptHeader."Vendor Authorization No.", SrcCode, ReturnShptHeader."No. Series")            else                ItemJnlLine.CopyDocumentFields(                  ItemJnlLine."Document Type"::"Purchase Receipt",                  PurchRcptHeader."No.", SetExternalDocumentNo(), SrcCode, PurchRcptHeader."No. Series");            if QtyToBeInvoiced <> 0 then                if ItemJnlLine."Document No." = '' then                    if PurchLine."Document Type" = PurchLine."Document Type"::"Credit Memo" then                        ItemJnlLine.CopyDocumentFields(                          ItemJnlLine."Document Type"::"Purchase Credit Memo", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, PurchHeader."Posting No. Series")                    else                        ItemJnlLine.CopyDocumentFields(                          ItemJnlLine."Document Type"::"Purchase Invoice", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, PurchHeader."Posting No. Series");        end;        OnPostItemJnlLineOnAfterCopyDocumentFields(ItemJnlLine, PurchLine, TempWhseRcptHeader, TempWhseShptHeader, PurchRcptHeader, GenJnlLineExtDocNo, QtyToBeInvoiced);    end;    local procedure PostItemJnlLineItemCharges(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; var OriginalItemJnlLine: Record "Item Journal Line"; ItemShptEntryNo: Integer; var TempTrackingSpecificationChargeAssmt: Record "Tracking Specification" temporary)    var        ItemChargePurchLine: Record "Purchase Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemJnlLineItemCharges(PurchHeader, PurchLine, IsHandled);        if not IsHandled then begin            ClearItemChargeAssgntFilter();            TempItemChargeAssgntPurch.SetCurrentKey(            "Applies-to Doc. Type", "Applies-to Doc. No.", "Applies-to Doc. Line No.");            TempItemChargeAssgntPurch.SetRange("Applies-to Doc. Type", PurchLine."Document Type");            TempItemChargeAssgntPurch.SetRange("Applies-to Doc. No.", PurchLine."Document No.");            TempItemChargeAssgntPurch.SetRange("Applies-to Doc. Line No.", PurchLine."Line No.");            if TempItemChargeAssgntPurch.Find('-') then                repeat                    PurchLine.TestField("Allow Item Charge Assignment");                    GetItemChargeLine(PurchHeader, ItemChargePurchLine);                    OnPostItemJnlLineItemChargesOnAfterGetItemChargeLine(ItemChargePurchLine, PurchLine);                    ItemChargePurchLine.CalcFields("Qty. Assigned");                    if (ItemChargePurchLine."Qty. to Invoice" <> 0) or                    (Abs(ItemChargePurchLine."Qty. Assigned") < Abs(ItemChargePurchLine."Quantity Invoiced"))                    then begin                        OriginalItemJnlLine."Item Shpt. Entry No." := ItemShptEntryNo;                        PostItemChargePerOrder(                        PurchHeader, PurchLine, OriginalItemJnlLine, ItemChargePurchLine, TempTrackingSpecificationChargeAssmt);                        TempItemChargeAssgntPurch.Mark(true);                    end;                until TempItemChargeAssgntPurch.Next() = 0;        end;        OnAfterPostItemJnlLineItemCharges(PurchHeader, PurchLine);    end;    local procedure PostItemJnlLineTracking(PurchLine: Record "Purchase Line"; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary; var TempTrackingSpecificationChargeAssmt: Record "Tracking Specification" temporary; PostWhseJnlLine: Boolean; QtyToBeInvoiced: Decimal)    begin        if ItemJnlPostLine.CollectTrackingSpecification(TempHandlingSpecification) then begin            OnPostItemJnlLineTrackingOnBeforeTempHandlingSpecificationFind(PurchLine, TempHandlingSpecification);            if TempHandlingSpecification.Find('-') then                repeat                    TempTrackingSpecification := TempHandlingSpecification;                    TempTrackingSpecification.SetSourceFromPurchLine(PurchLine);                    if TempTrackingSpecification.Insert() then;                    if QtyToBeInvoiced <> 0 then begin                        TempTrackingSpecificationInv := TempTrackingSpecification;                        if TempTrackingSpecificationInv.Insert() then;                    end;                    if PostWhseJnlLine then begin                        TempWhseTrackingSpecification := TempTrackingSpecification;                        if TempWhseTrackingSpecification.Insert() then;                    end;                    TempTrackingSpecificationChargeAssmt := TempTrackingSpecification;                    TempTrackingSpecificationChargeAssmt.Insert();                until TempHandlingSpecification.Next() = 0;        end;    end;    local procedure PostItemJnlLineWhseLine(var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary; PurchLine: Record "Purchase Line"; PostBefore: Boolean)    var        TempWhseJnlLine2: Record "Warehouse Journal Line" temporary;        PositiveWhseEntryCreated: Boolean;    begin        OnBeforePostItemJnlLineWhseLine(TempWhseJnlLine, TempWhseTrackingSpecification, PurchLine, PostBefore);        ItemTrackingMgt.SplitWhseJnlLine(TempWhseJnlLine, TempWhseJnlLine2, TempWhseTrackingSpecification, false);        OnPostItemJnlLineWhseLineOnBeforeTempWhseJnlLine2Find(TempWhseJnlLine2, PurchLine, WhseReceive, WhseShip, InvtPickPutaway);        if TempWhseJnlLine2.Find('-') then            repeat                PositiveWhseEntryCreated := false;                if PurchLine.IsCreditDocType() and (PurchLine.Quantity > 0) or                   PurchLine.IsInvoiceDocType() and (PurchLine.Quantity < 0)                then                    PositiveWhseEntryCreated := CreatePositiveEntry(TempWhseJnlLine2, PurchLine."Job No.", PostBefore);                OnPostItemJnlLineWhseLineOnBeforePostSingleLine(WhseShip, WhseReceive, InvtPickPutaway, TempWhseJnlLine2);                WhseJnlPostLine.Run(TempWhseJnlLine2);                if not PositiveWhseEntryCreated then                    if RevertWarehouseEntry(TempWhseJnlLine2, PurchLine."Job No.", PostBefore) then begin                        WhseJnlPostLine.Run(TempWhseJnlLine2);                        OnPostItemJnlLineWhseLineOnAfterPostRevert(TempWhseJnlLine2, PurchLine);                    end;            until TempWhseJnlLine2.Next() = 0;        TempWhseTrackingSpecification.DeleteAll();        OnAfterPostItemJnlLineWhseLine(TempWhseJnlLine, TempWhseTrackingSpecification, PurchLine);    end;    local procedure ShouldPostWhseJnlLine(PurchLine: Record "Purchase Line"; var ItemJnlLine: Record "Item Journal Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary) Result: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeShouldPostWhseJnlLine(PurchLine, Result, IsHandled, ItemJnlLine, TempWhseJnlLine, WhseReceive, WhseShip, InvtPickPutaway, SrcCode);        if IsHandled then            exit(Result);        if (PurchLine."Location Code" <> '') and (PurchLine.Type = PurchLine.Type::Item) and (ItemJnlLine.Quantity <> 0) and            not ItemJnlLine.Subcontracting and PurchLine.IsInventoriableItem()        then begin            GetLocation(PurchLine."Location Code");            if ((PurchLine."Document Type" in [PurchLine."Document Type"::Invoice, PurchLine."Document Type"::"Credit Memo"]) and                Location."Directed Put-away and Pick") or               (Location."Bin Mandatory" and not (WhseReceive or WhseShip or InvtPickPutaway or PurchLine."Drop Shipment"))            then begin                CreateWhseJnlLine(ItemJnlLine, PurchLine, TempWhseJnlLine);                exit(true);            end;        end;    end;    local procedure PostItemChargePerOrder(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; ItemJnlLine2: Record "Item Journal Line"; ItemChargePurchLine: Record "Purchase Line"; var TempTrackingSpecificationChargeAssmt: Record "Tracking Specification" temporary)    var        QtyToInvoice: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemChargePerOrder(          PurchHeader, PurchLine, ItemJnlLine2, ItemChargePurchLine, TempTrackingSpecificationChargeAssmt, SuppressCommit,          TempItemChargeAssgntPurch, IsHandled);        if not IsHandled then begin            PurchLine.TestField("Allow Item Charge Assignment", true);            ItemJnlLine2."Document No." := GenJnlLineDocNo;            ItemJnlLine2."External Document No." := GenJnlLineExtDocNo;            ItemJnlLine2."Item Charge No." := TempItemChargeAssgntPurch."Item Charge No.";            ItemJnlLine2.Description := ItemChargePurchLine.Description;            ItemJnlLine2."Document Line No." := ItemChargePurchLine."Line No.";            ItemJnlLine2."Unit of Measure Code" := '';            ItemJnlLine2."Qty. per Unit of Measure" := 1;            if TempItemChargeAssgntPurch."Document Type" in [TempItemChargeAssgntPurch."Document Type"::"Return Order", TempItemChargeAssgntPurch."Document Type"::"Credit Memo"] then                QtyToInvoice :=                CalcQtyToInvoice(PurchLine."Return Qty. to Ship (Base)", PurchLine."Qty. to Invoice (Base)")            else                QtyToInvoice :=                CalcQtyToInvoice(PurchLine."Qty. to Receive (Base)", PurchLine."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.Amount := TempItemChargeAssgntPurch."Amount to Handle" * ItemJnlLine2."Invoiced Qty. (Base)" / QtyToInvoice;            if TempItemChargeAssgntPurch."Document Type" in [TempItemChargeAssgntPurch."Document Type"::"Return Order", TempItemChargeAssgntPurch."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 PurchHeader."Currency Code" <> '' then                ItemJnlLine2.Amount :=                CurrExchRate.ExchangeAmtFCYToLCY(                    PurchHeader.GetUseDate(), PurchHeader."Currency Code", PreciseTotalChargeAmt + TotalPurchLine.Amount, PurchHeader."Currency Factor") -                RoundedPrevTotalChargeAmt - TotalPurchLineLCY.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.";            ItemJnlLine2."Overhead Rate" := 0;            if PurchHeader."Currency Code" <> '' then                ItemJnlLine2."Discount Amount" := Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      PurchHeader.GetUseDate(), PurchHeader."Currency Code",                      (ItemChargePurchLine."Inv. Discount Amount" + ItemChargePurchLine."Line Discount Amount") *                       ItemJnlLine2."Invoiced Qty. (Base)" /                      ItemChargePurchLine."Quantity (Base)" * TempItemChargeAssgntPurch."Qty. to Handle" / QtyToInvoice,                      PurchHeader."Currency Factor"), GLSetup."Amount Rounding Precision")            else                ItemJnlLine2."Discount Amount" := Round(                    (ItemChargePurchLine."Line Discount Amount" + ItemChargePurchLine."Inv. Discount Amount") *                    ItemJnlLine2."Invoiced Qty. (Base)" /                    ItemChargePurchLine."Quantity (Base)" * TempItemChargeAssgntPurch."Qty. to Handle" / QtyToInvoice,                    GLSetup."Amount Rounding Precision");            ItemJnlLine2."Shortcut Dimension 1 Code" := ItemChargePurchLine."Shortcut Dimension 1 Code";            ItemJnlLine2."Shortcut Dimension 2 Code" := ItemChargePurchLine."Shortcut Dimension 2 Code";            ItemJnlLine2."Dimension Set ID" := ItemChargePurchLine."Dimension Set ID";            UpdateItemJnlLineDimSetIDFromAppliedShipmentEntry(ItemJnlLine2);            ItemJnlLine2."Gen. Prod. Posting Group" := ItemChargePurchLine."Gen. Prod. Posting Group";            OnPostItemChargePerOrderOnAfterCopyToItemJnlLine(                ItemJnlLine2, ItemChargePurchLine, GLSetup, QtyToInvoice, TempItemChargeAssgntPurch, PurchLine);            PostItemTrackingItemChargePerOrder(PurchHeader, ItemJnlLine2, TempTrackingSpecificationChargeAssmt);        end;        OnAfterPostItemChargePerOrder(PurchHeader, PurchLine);    end;    local procedure PostItemTrackingItemChargePerOrder(PurchHeader: Record "Purchase Header"; var ItemJnlLine2: Record "Item Journal Line"; var TempTrackingSpecificationChargeAssmt: Record "Tracking Specification" temporary)    var        NonDistrItemJnlLine: Record "Item Journal Line";        OriginalAmt: Decimal;        OriginalAmtACY: Decimal;        OriginalDiscountAmt: Decimal;        OriginalQty: Decimal;        SignFactor: Integer;        Factor: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemTrackingItemChargePerOrder(TempTrackingSpecificationInv, IsHandled, ItemJnlLine2, TempTrackingSpecificationChargeAssmt);        if IsHandled then            exit;        TempTrackingSpecificationChargeAssmt.Reset();        TempTrackingSpecificationChargeAssmt.SetRange("Source Type", DATABASE::"Purchase Line");        TempTrackingSpecificationChargeAssmt.SetRange("Source ID", TempItemChargeAssgntPurch."Applies-to Doc. No.");        TempTrackingSpecificationChargeAssmt.SetRange("Source Ref. No.", TempItemChargeAssgntPurch."Applies-to Doc. Line No.");        if TempTrackingSpecificationChargeAssmt.IsEmpty() then            RunItemJnlPostLine(ItemJnlLine2)        else begin            TempTrackingSpecificationChargeAssmt.FindSet();            NonDistrItemJnlLine := ItemJnlLine2;            OriginalAmt := NonDistrItemJnlLine.Amount;            OriginalAmtACY := NonDistrItemJnlLine."Amount (ACY)";            OriginalDiscountAmt := NonDistrItemJnlLine."Discount Amount";            OriginalQty := NonDistrItemJnlLine."Quantity (Base)";            if (TempTrackingSpecificationChargeAssmt."Quantity (Base)" / OriginalQty) > 0 then                SignFactor := 1            else                SignFactor := -1;            repeat                Factor := TempTrackingSpecificationChargeAssmt."Quantity (Base)" / OriginalQty * SignFactor;                OnPostItemTrackingItemChargePerOrderOnAfterCalcFactor(NonDistrItemJnlLine, ItemJnlLine2, TempTrackingSpecificationChargeAssmt, SignFactor, Factor);                if Abs(TempTrackingSpecificationChargeAssmt."Quantity (Base)") < Abs(NonDistrItemJnlLine."Quantity (Base)") then begin                    ItemJnlLine2."Quantity (Base)" := TempTrackingSpecificationChargeAssmt."Quantity (Base)";                    ItemJnlLine2."Invoiced Qty. (Base)" := ItemJnlLine2."Quantity (Base)";                    if PurchHeader."Currency Code" <> '' then begin                        PreciseTotalChargeAmt +=                          CurrExchRate.ExchangeAmtLCYToFCY(                            PurchHeader.GetUseDate(), PurchHeader."Currency Code", OriginalAmt * Factor, PurchHeader."Currency Factor");                        ItemJnlLine2.Amount :=                          CurrExchRate.ExchangeAmtFCYToLCY(                            PurchHeader.GetUseDate(), PurchHeader."Currency Code", PreciseTotalChargeAmt + TotalPurchLine.Amount, PurchHeader."Currency Factor") -                          RoundedPrevTotalChargeAmt - TotalPurchLineLCY.Amount;                    end else begin                        PreciseTotalChargeAmt += OriginalAmt * Factor;                        ItemJnlLine2.Amount := PreciseTotalChargeAmt - RoundedPrevTotalChargeAmt;                    end;                    PreciseTotalChargeAmtACY += OriginalAmtACY * Factor;                    ItemJnlLine2."Amount (ACY)" := PreciseTotalChargeAmtACY - RoundedPrevTotalChargeAmtACY;                    ItemJnlLine2.Amount :=                        Round(ItemJnlLine2.Amount, GLSetup."Amount Rounding Precision");                    ItemJnlLine2."Amount (ACY)" :=                        Round(ItemJnlLine2."Amount (ACY)", Currency."Amount Rounding Precision");                    RoundedPrevTotalChargeAmt += ItemJnlLine2.Amount;                    RoundedPrevTotalChargeAmtACY += ItemJnlLine2."Amount (ACY)";                    ItemJnlLine2."Unit Cost (ACY)" :=                      Round(ItemJnlLine2.Amount / ItemJnlLine2."Invoiced Qty. (Base)",                        Currency."Unit-Amount Rounding Precision") * SignFactor;                    ItemJnlLine2."Unit Cost" :=                      Round(ItemJnlLine2.Amount / ItemJnlLine2."Invoiced Qty. (Base)",                        GLSetup."Unit-Amount Rounding Precision") * SignFactor;                    ItemJnlLine2."Discount Amount" :=                      Round(OriginalDiscountAmt * Factor, GLSetup."Amount Rounding Precision");                    ItemJnlLine2."Item Shpt. Entry No." := TempTrackingSpecificationChargeAssmt."Item Ledger Entry No.";                    ItemJnlLine2."Applies-to Entry" := TempTrackingSpecificationChargeAssmt."Item Ledger Entry No.";                    ItemJnlLine2.CopyTrackingFromSpec(TempTrackingSpecificationChargeAssmt);                    RunItemJnlPostLine(ItemJnlLine2);                    ItemJnlLine2."Location Code" := NonDistrItemJnlLine."Location Code";                    OnPostItemTrackingItemChargePerOrderOnAfterUpdateItemJnlLine2LocationCode(ItemJnlLine2);                    NonDistrItemJnlLine."Quantity (Base)" -= TempTrackingSpecificationChargeAssmt."Quantity (Base)";                    NonDistrItemJnlLine.Amount -= (ItemJnlLine2.Amount * SignFactor);                    NonDistrItemJnlLine."Amount (ACY)" -= (ItemJnlLine2."Amount (ACY)" * SignFactor);                    NonDistrItemJnlLine."Discount Amount" -= (ItemJnlLine2."Discount Amount" * SignFactor);                end else begin                    NonDistrItemJnlLine."Quantity (Base)" := TempTrackingSpecificationChargeAssmt."Quantity (Base)";                    NonDistrItemJnlLine."Invoiced Qty. (Base)" := TempTrackingSpecificationChargeAssmt."Quantity (Base)";                    NonDistrItemJnlLine."Unit Cost" :=                      Round(NonDistrItemJnlLine.Amount / NonDistrItemJnlLine."Invoiced Qty. (Base)",                        GLSetup."Unit-Amount Rounding Precision") * SignFactor;                    NonDistrItemJnlLine."Unit Cost (ACY)" :=                      Round(NonDistrItemJnlLine.Amount / NonDistrItemJnlLine."Invoiced Qty. (Base)",                        Currency."Unit-Amount Rounding Precision") * SignFactor;                    NonDistrItemJnlLine."Item Shpt. Entry No." := TempTrackingSpecificationChargeAssmt."Item Ledger Entry No.";                    NonDistrItemJnlLine."Applies-to Entry" := TempTrackingSpecificationChargeAssmt."Item Ledger Entry No.";                    NonDistrItemJnlLine.CopyTrackingFromSpec(TempTrackingSpecificationChargeAssmt);                    RunItemJnlPostLine(NonDistrItemJnlLine);                    NonDistrItemJnlLine."Location Code" := ItemJnlLine2."Location Code";                end;            until TempTrackingSpecificationChargeAssmt.Next() = 0;        end;    end;    local procedure PostItemChargePerRcpt(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line")    var        PurchRcptLine: Record "Purch. Rcpt. Line";        TempItemLedgEntry: Record "Item Ledger Entry" temporary;        Sign: Decimal;        DistributeCharge: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemChargePerRcpt(PurchHeader, PurchLine, TempItemChargeAssgntPurch, IsHandled);        if IsHandled then            exit;        if not PurchRcptLine.Get(             TempItemChargeAssgntPurch."Applies-to Doc. No.", TempItemChargeAssgntPurch."Applies-to Doc. Line No.")        then            Error(ReceiptLinesDeletedErr);        OnPostItemChargePerRcptOnAfterPurchRcptLineGet(PurchRcptLine, PurchLine);        Sign := 1;        if PurchRcptLine."Item Rcpt. Entry No." <> 0 then            DistributeCharge :=              CostCalcMgt.SplitItemLedgerEntriesExist(                TempItemLedgEntry, PurchRcptLine."Quantity (Base)", PurchRcptLine."Item Rcpt. Entry No.")        else begin            DistributeCharge := true;            ItemTrackingMgt.CollectItemEntryRelation(TempItemLedgEntry,              DATABASE::"Purch. Rcpt. Line", 0, PurchRcptLine."Document No.",              '', 0, PurchRcptLine."Line No.", PurchRcptLine."Quantity (Base)");        end;        OnPostItemChargePerRcptOnAfterCalcDistributeCharge(PurchHeader, PurchLine, PurchRcptLine, TempItemLedgEntry, DistributeCharge);        if DistributeCharge then            PostDistributeItemCharge(              PurchHeader, PurchLine, TempItemLedgEntry, PurchRcptLine."Quantity (Base)",              TempItemChargeAssgntPurch."Qty. to Assign", TempItemChargeAssgntPurch."Amount to Assign",              Sign, PurchRcptLine."Indirect Cost %")        else            PostItemCharge(PurchHeader, PurchLine,              PurchRcptLine."Item Rcpt. Entry No.", PurchRcptLine."Quantity (Base)",              TempItemChargeAssgntPurch."Amount to Assign" * Sign,              TempItemChargeAssgntPurch."Qty. to Assign",              PurchRcptLine."Indirect Cost %");    end;    local procedure PostItemChargePerRetShpt(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line")    var        ReturnShptLine: Record "Return Shipment Line";        TempItemLedgEntry: Record "Item Ledger Entry" temporary;        Sign: Decimal;        DistributeCharge: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemChargePerRetShpt(PurchHeader, PurchLine, TempItemChargeAssgntPurch, IsHandled);        if IsHandled then            exit;        ReturnShptLine.Get(          TempItemChargeAssgntPurch."Applies-to Doc. No.", TempItemChargeAssgntPurch."Applies-to Doc. Line No.");        IsHandled := false;        OnPostItemChargePerRetShptOnBeforeTestJobNo(ReturnShptLine, IsHandled, PurchLine);        if not IsHandled then            ReturnShptLine.TestField("Job No.", '');        Sign := GetSign(PurchLine."Line Amount");        if PurchLine.IsCreditDocType() then            Sign := -Sign;        if ReturnShptLine."Item Shpt. Entry No." <> 0 then            DistributeCharge :=              CostCalcMgt.SplitItemLedgerEntriesExist(                TempItemLedgEntry, -ReturnShptLine."Quantity (Base)", ReturnShptLine."Item Shpt. Entry No.")        else begin            DistributeCharge := true;            ItemTrackingMgt.CollectItemEntryRelation(TempItemLedgEntry,              DATABASE::"Return Shipment Line", 0, ReturnShptLine."Document No.",              '', 0, ReturnShptLine."Line No.", ReturnShptLine."Quantity (Base)");        end;        OnPostItemChargePerRetShptOnAfterCalcDistributeCharge(PurchHeader, PurchLine, ReturnShptLine, TempItemLedgEntry, DistributeCharge);        if DistributeCharge then            PostDistributeItemCharge(              PurchHeader, PurchLine, TempItemLedgEntry, -ReturnShptLine."Quantity (Base)",              TempItemChargeAssgntPurch."Qty. to Handle", Abs(TempItemChargeAssgntPurch."Amount to Handle"),              Sign, ReturnShptLine."Indirect Cost %")        else            PostItemCharge(PurchHeader, PurchLine,              ReturnShptLine."Item Shpt. Entry No.", -ReturnShptLine."Quantity (Base)",              Abs(TempItemChargeAssgntPurch."Amount to Handle") * Sign,              TempItemChargeAssgntPurch."Qty. to Handle",              ReturnShptLine."Indirect Cost %");        OnAfterPostItemChargePerRetShpt(PurchLine);    end;    local procedure PostItemChargePerTransfer(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line")    var        TransRcptLine: Record "Transfer Receipt Line";        ItemApplnEntry: Record "Item Application Entry";        DummyTrackingSpecification: Record "Tracking Specification";        PurchLine2: Record "Purchase Line";        TotalAmountToPostFCY: Decimal;        TotalAmountToPostLCY: Decimal;        TotalDiscAmountToPost: Decimal;        AmountToPostFCY: Decimal;        AmountToPostLCY: Decimal;        DiscAmountToPost: Decimal;        RemAmountToPostFCY: Decimal;        RemAmountToPostLCY: Decimal;        RemDiscAmountToPost: Decimal;        CalcAmountToPostFCY: Decimal;        CalcAmountToPostLCY: Decimal;        CalcDiscAmountToPost: Decimal;        IsHandled: Boolean;    begin        TransRcptLine.Get(TempItemChargeAssgntPurch."Applies-to Doc. No.", TempItemChargeAssgntPurch."Applies-to Doc. Line No.");        PurchLine2 := PurchLine;        PurchLine2."No." := TempItemChargeAssgntPurch."Item No.";        PurchLine2."Variant Code" := TransRcptLine."Variant Code";        PurchLine2."Location Code" := TransRcptLine."Transfer-to Code";        PurchLine2."Bin Code" := '';        PurchLine2."Line No." := TempItemChargeAssgntPurch."Document Line No.";        OnPostItemChargePerTransferOnAfterInitPurchLine2(TransRcptLine, PurchLine2);        if TransRcptLine."Item Rcpt. Entry No." = 0 then            PostItemChargePerITTransfer(PurchHeader, PurchLine, TransRcptLine)        else begin            TotalAmountToPostFCY := TempItemChargeAssgntPurch."Amount to Assign";            if PurchHeader."Currency Code" <> '' then                TotalAmountToPostLCY :=                  CurrExchRate.ExchangeAmtFCYToLCY(                    PurchHeader.GetUseDate(), PurchHeader."Currency Code",                    TotalAmountToPostFCY, PurchHeader."Currency Factor")            else                TotalAmountToPostLCY := TotalAmountToPostFCY;            TotalDiscAmountToPost :=              Round(                PurchLine2."Inv. Discount Amount" / PurchLine2.Quantity * TempItemChargeAssgntPurch."Qty. to Assign",                GLSetup."Amount Rounding Precision");            TotalDiscAmountToPost :=              TotalDiscAmountToPost +              Round(                PurchLine2."Line Discount Amount" * (TempItemChargeAssgntPurch."Qty. to Assign" / PurchLine2."Qty. to Invoice"),                GLSetup."Amount Rounding Precision");            TotalAmountToPostLCY := Round(TotalAmountToPostLCY, GLSetup."Amount Rounding Precision");            IsHandled := false;            OnPostItemChargePerTransferOnBeforeProcessItemApplicationEntry(PurchLine2, ItemApplnEntry, TransRcptLine, TotalAmountToPostFCY, AmountToPostFCY, GLSetup, PurchHeader, IsHandled);            if not IsHandled then begin                ItemApplnEntry.SetCurrentKey("Outbound Item Entry No.", "Item Ledger Entry No.", "Cost Application");                ItemApplnEntry.SetRange("Outbound Item Entry No.", TransRcptLine."Item Rcpt. Entry No.");                ItemApplnEntry.SetFilter("Item Ledger Entry No.", '<>%1', TransRcptLine."Item Rcpt. Entry No.");                ItemApplnEntry.SetRange("Cost Application", true);                if ItemApplnEntry.FindSet() then                    repeat                        PurchLine2."Appl.-to Item Entry" := ItemApplnEntry."Item Ledger Entry No.";                        CalcAmountToPostFCY :=                          ((TotalAmountToPostFCY / TransRcptLine."Quantity (Base)") * ItemApplnEntry.Quantity) +                          RemAmountToPostFCY;                        AmountToPostFCY := Round(CalcAmountToPostFCY);                        RemAmountToPostFCY := CalcAmountToPostFCY - AmountToPostFCY;                        CalcAmountToPostLCY :=                          ((TotalAmountToPostLCY / TransRcptLine."Quantity (Base)") * ItemApplnEntry.Quantity) +                          RemAmountToPostLCY;                        AmountToPostLCY := Round(CalcAmountToPostLCY);                        RemAmountToPostLCY := CalcAmountToPostLCY - AmountToPostLCY;                        CalcDiscAmountToPost :=                          ((TotalDiscAmountToPost / TransRcptLine."Quantity (Base)") * ItemApplnEntry.Quantity) +                          RemDiscAmountToPost;                        DiscAmountToPost := Round(CalcDiscAmountToPost);                        RemDiscAmountToPost := CalcDiscAmountToPost - DiscAmountToPost;                        PurchLine2.Amount := AmountToPostLCY;                        PurchLine2."Inv. Discount Amount" := DiscAmountToPost;                        PurchLine2."Line Discount Amount" := 0;                        PurchLine2."Unit Cost" :=                          Round(AmountToPostFCY / ItemApplnEntry.Quantity, GLSetup."Unit-Amount Rounding Precision");                        PurchLine2."Unit Cost (LCY)" :=                          Round(AmountToPostLCY / ItemApplnEntry.Quantity, GLSetup."Unit-Amount Rounding Precision");                        if TempItemChargeAssgntPurch."Document Type" in [TempItemChargeAssgntPurch."Document Type"::"Return Order", TempItemChargeAssgntPurch."Document Type"::"Credit Memo"] then                            PurchLine2.Amount := -PurchLine2.Amount;                        OnPostItemChargePerTransferOnBeforePostItemJnlLine(PurchHeader, PurchLine2, ItemApplnEntry, TransRcptLine, TempItemChargeAssgntPurch);                        PostItemJnlLine(                          PurchHeader, PurchLine2,                          0, 0,                          ItemApplnEntry.Quantity, ItemApplnEntry.Quantity,                          PurchLine2."Appl.-to Item Entry", TempItemChargeAssgntPurch."Item Charge No.", DummyTrackingSpecification);                    until ItemApplnEntry.Next() = 0;            end;        end;        OnAfterPostItemChargePerTransfer(PurchLine);    end;    local procedure PostItemChargePerITTransfer(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; TransRcptLine: Record "Transfer Receipt Line")    var        TempItemLedgerEntry: Record "Item Ledger Entry" temporary;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemChargePerITTransfer(PurchHeader, PurchLine, TransRcptLine, TempItemChargeAssgntPurch, IsHandled);        if not IsHandled then begin            ItemTrackingMgt.CollectItemEntryRelation(TempItemLedgerEntry,                DATABASE::"Transfer Receipt Line", 0, TransRcptLine."Document No.",                '', 0, TransRcptLine."Line No.", TransRcptLine."Quantity (Base)");            OnPostItemChargePerITTransferOnAfterCollectItemEntryRelation(PurchHeader, PurchLine, TransRcptLine, TempItemLedgerEntry);            PostDistributeItemCharge(                PurchHeader, PurchLine, TempItemLedgerEntry, TransRcptLine."Quantity (Base)",                TempItemChargeAssgntPurch."Qty. to Assign", TempItemChargeAssgntPurch."Amount to Assign", 1, 0);        end;    end;    local procedure PostItemChargePerSalesShpt(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line")    var        SalesShptLine: Record "Sales Shipment Line";        TempItemLedgEntry: Record "Item Ledger Entry" temporary;        Sign: Decimal;        DistributeCharge: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemChargePerSalesShpt(TempItemChargeAssgntPurch, PurchLine, IsHandled);        if IsHandled then            exit;        if not SalesShptLine.Get(             TempItemChargeAssgntPurch."Applies-to Doc. No.", TempItemChargeAssgntPurch."Applies-to Doc. Line No.")        then            Error(RelatedItemLedgEntriesNotFoundErr);        IsHandled := false;        OnPostItemChargePerSalesShptOnBeforeTestJobNo(SalesShptLine, IsHandled, PurchLine);        if not IsHandled then            SalesShptLine.TestField("Job No.", '');        Sign := -GetSign(SalesShptLine."Quantity (Base)");        if SalesShptLine."Item Shpt. Entry No." <> 0 then            DistributeCharge :=              CostCalcMgt.SplitItemLedgerEntriesExist(                TempItemLedgEntry, -SalesShptLine."Quantity (Base)", SalesShptLine."Item Shpt. Entry No.")        else begin            DistributeCharge := true;            ItemTrackingMgt.CollectItemEntryRelation(TempItemLedgEntry,              DATABASE::"Sales Shipment Line", 0, SalesShptLine."Document No.",              '', 0, SalesShptLine."Line No.", SalesShptLine."Quantity (Base)");        end;        OnPostItemChargePerSalesShptOnAfterCalcDistributeCharge(PurchHeader, PurchLine, SalesShptLine, TempItemLedgEntry, DistributeCharge);        if DistributeCharge then            PostDistributeItemCharge(              PurchHeader, PurchLine, TempItemLedgEntry, -SalesShptLine."Quantity (Base)",              TempItemChargeAssgntPurch."Qty. to Assign", TempItemChargeAssgntPurch."Amount to Assign", Sign, 0)        else            PostItemCharge(PurchHeader, PurchLine,              SalesShptLine."Item Shpt. Entry No.", -SalesShptLine."Quantity (Base)",              TempItemChargeAssgntPurch."Amount to Assign" * Sign,              TempItemChargeAssgntPurch."Qty. to Assign", 0);        OnAfterPostItemChargePerSalesShpt(PurchLine);    end;    local procedure PostItemChargePerRetRcpt(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line")    var        ReturnRcptLine: Record "Return Receipt Line";        TempItemLedgEntry: Record "Item Ledger Entry" temporary;        Sign: Decimal;        DistributeCharge: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemChargePerRetRcpt(PurchHeader, PurchLine, TempItemChargeAssgntPurch, IsHandled);        if IsHandled then            exit;        if not ReturnRcptLine.Get(             TempItemChargeAssgntPurch."Applies-to Doc. No.", TempItemChargeAssgntPurch."Applies-to Doc. Line No.")        then            Error(RelatedItemLedgEntriesNotFoundErr);        IsHandled := false;        OnPostItemChargePerSalesRetRcptOnBeforeTestJobNo(ReturnRcptLine, IsHandled, PurchLine);        if not IsHandled then            ReturnRcptLine.TestField("Job No.", '');        Sign := GetSign(ReturnRcptLine."Quantity (Base)");        if ReturnRcptLine."Item Rcpt. Entry No." <> 0 then            DistributeCharge :=              CostCalcMgt.SplitItemLedgerEntriesExist(                TempItemLedgEntry, ReturnRcptLine."Quantity (Base)", ReturnRcptLine."Item Rcpt. Entry No.")        else begin            DistributeCharge := true;            ItemTrackingMgt.CollectItemEntryRelation(TempItemLedgEntry,              DATABASE::"Return Receipt Line", 0, ReturnRcptLine."Document No.",              '', 0, ReturnRcptLine."Line No.", ReturnRcptLine."Quantity (Base)");        end;        OnPostItemChargePerRetRcptOnAfterCalcDistributeCharge(PurchHeader, PurchLine, ReturnRcptLine, TempItemLedgEntry, DistributeCharge);        if DistributeCharge then            PostDistributeItemCharge(              PurchHeader, PurchLine, TempItemLedgEntry, ReturnRcptLine."Quantity (Base)",              TempItemChargeAssgntPurch."Qty. to Handle", TempItemChargeAssgntPurch."Amount to Assign", Sign, 0)        else            PostItemCharge(PurchHeader, PurchLine,              ReturnRcptLine."Item Rcpt. Entry No.", ReturnRcptLine."Quantity (Base)",              TempItemChargeAssgntPurch."Amount to Handle" * Sign,              TempItemChargeAssgntPurch."Qty. to Handle", 0);        OnAfterPostItemChargePerRetRcpt(PurchLine);    end;    /// <summary>    /// Calculates and posts distribution of item charges    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    /// <param name="TempItemLedgEntry">Temporary item ledger entries against which distribution of item charges is being calculated and posted</param>    /// <param name="NonDistrQuantity">Quantity to be distributed</param>    /// <param name="NonDistrQtyToAssign">Quantity to be distributed and assigned</param>    /// <param name="NonDistrAmountToAssign">Amount to be distributed and assigned</param>    /// <param name="Sign">Number to multiply the Amount with. Should either be 1 or -1 to change the sign of the operation (positive/negative)</param>    /// <param name="IndirectCostPct">Indirect Cost percentage that will be assigned to purchase line field "Indirect Cost %" </param>    procedure PostDistributeItemCharge(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; var TempItemLedgEntry: Record "Item Ledger Entry" temporary; NonDistrQuantity: Decimal; NonDistrQtyToAssign: Decimal; NonDistrAmountToAssign: Decimal; Sign: Decimal; IndirectCostPct: Decimal)    var        Factor: Decimal;        QtyToAssign: Decimal;        AmountToAssign: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostDistributeItemCharge(PurchHeader, PurchLine, TempItemLedgEntry, NonDistrQuantity, NonDistrQtyToAssign, NonDistrAmountToAssign, Sign, IndirectCostPct, IsHandled);        if IsHandled then            exit;        if TempItemLedgEntry.FindSet() then            repeat                Factor := TempItemLedgEntry.Quantity / NonDistrQuantity;                OnPostDistributeItemChargeOnAfterSetFactor(TempItemLedgEntry, Factor);                QtyToAssign := NonDistrQtyToAssign * Factor;                AmountToAssign := Round(NonDistrAmountToAssign * Factor, GLSetup."Amount Rounding Precision");                OnPostDistributeItemChargeOnAfterCalcAmountToAssign(PurchLine, TempItemLedgEntry, QtyToAssign, AmountToAssign, Sign, Factor);                if Factor < 1 then begin                    PostItemCharge(PurchHeader, PurchLine,                      TempItemLedgEntry."Entry No.", TempItemLedgEntry.Quantity,                      AmountToAssign * Sign, QtyToAssign, IndirectCostPct);                    NonDistrQuantity := NonDistrQuantity - TempItemLedgEntry.Quantity;                    NonDistrQtyToAssign := NonDistrQtyToAssign - QtyToAssign;                    NonDistrAmountToAssign := NonDistrAmountToAssign - AmountToAssign;                end else // the last time                    PostItemCharge(PurchHeader, PurchLine,                      TempItemLedgEntry."Entry No.", TempItemLedgEntry.Quantity,                      NonDistrAmountToAssign * Sign, NonDistrQtyToAssign, IndirectCostPct);            until TempItemLedgEntry.Next() = 0        else            Error(RelatedItemLedgEntriesNotFoundErr)    end;    procedure PostAssocItemJnlLine(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal): Integer    var        ItemJnlLine: Record "Item Journal Line";        TempHandlingSpecification2: Record "Tracking Specification" temporary;        ItemEntryRelation: Record "Item Entry Relation";        SalesOrderHeader: Record "Sales Header";        SalesOrderLine: Record "Sales Line";        ErrorContextElementSalesLine: Codeunit "Error Context Element";        IsHandled: Boolean;        ItemShptEntryNo: Integer;    begin        IsHandled := false;        OnBeforeProcedurePostAssocItemJnlLine(SalesOrderLine, TempTrackingSpecification, TempHandlingSpecification, QtyToBeShipped, QtyToBeShippedBase, ItemShptEntryNo, IsHandled);        if not IsHandled then begin            SalesOrderHeader.Get(              SalesOrderHeader."Document Type"::Order, PurchLine."Sales Order No.");            SalesOrderLine.Get(              SalesOrderLine."Document Type"::Order, PurchLine."Sales Order No.", PurchLine."Sales Order Line No.");            ErrorMessageMgt.PushContext(ErrorContextElementSalesLine, SalesOrderLine.RecordId, 0, '');            IsHandled := false;            OnPostAssocItemJnlLineOnBeforeInitAssocItemJnlLine(SalesOrderLine, ItemShptEntryNo, IsHandled);            if IsHandled then                exit(ItemShptEntryNo);            InitAssocItemJnlLine(ItemJnlLine, SalesOrderHeader, SalesOrderLine, PurchHeader, QtyToBeShipped, QtyToBeShippedBase);            IsHandled := false;            OnPostAssocItemJnlLineOnBeforePost(ItemJnlLine, SalesOrderLine, IsHandled);            if (SalesOrderLine."Job Contract Entry No." = 0) or IsHandled then begin                TransferReservToItemJnlLine(SalesOrderLine, ItemJnlLine, PurchLine, QtyToBeShippedBase, true);                OnBeforePostAssocItemJnlLine(ItemJnlLine, SalesOrderLine, SuppressCommit, PurchLine);                RunItemJnlPostLine(ItemJnlLine);                OnAfterPostAssocItemJnlLine(ItemJnlLine, ItemJnlPostLine, SalesOrderLine, SalesOrderHeader, TempTrackingSpecification);                // Handle Item Tracking                if ItemJnlPostLine.CollectTrackingSpecification(TempHandlingSpecification2) then begin                    if TempHandlingSpecification2.FindSet() then                        repeat                            TempTrackingSpecification := TempHandlingSpecification2;                            TempTrackingSpecification.SetSourceFromSalesLine(SalesOrderLine);                            if TempTrackingSpecification.Insert() then;                            ItemEntryRelation.InitFromTrackingSpec(TempHandlingSpecification2);                            ItemEntryRelation.SetSource(DATABASE::"Sales Shipment Line", 0, SalesOrderHeader."Shipping No.", SalesOrderLine."Line No.");                            ItemEntryRelation.SetOrderInfo(SalesOrderLine."Document No.", SalesOrderLine."Line No.");                            ItemEntryRelation.Insert();                        until TempHandlingSpecification2.Next() = 0;                    exit(0);                end;            end;            IsHandled := false;            ItemShptEntryNo := ItemJnlLine."Item Shpt. Entry No.";        end;        OnPostAssocItemJnlLineOnBeforeExit(SalesOrderHeader, ItemShptEntryNo, IsHandled);        exit(ItemShptEntryNo);    end;    local procedure PostResourceLine(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostResourceLine(PurchaseHeader, PurchaseLine, IsHandled,            SrcCode, GenJnlLineExtDocNo, GenJnlLineDocNo, PurchInvHeader, PurchCrMemoHeader, JobPurchLine);        if not IsHandled then            PostResJnlLine(PurchaseHeader, PurchaseLine);    end;    procedure InitAssocItemJnlLine(var ItemJnlLine: Record "Item Journal Line"; SalesOrderHeader: Record "Sales Header"; SalesOrderLine: Record "Sales Line"; PurchHeader: Record "Purchase Header"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal)    begin        OnBeforeInitAssocItemJnlLine(ItemJnlLine, SalesOrderHeader, SalesOrderLine, PurchHeader);        ItemJnlLine.Init();        ItemJnlLine.CopyDocumentFields(          ItemJnlLine."Document Type"::"Sales Shipment", SalesOrderHeader."Shipping No.", '', SrcCode, SalesOrderHeader."Posting No. Series");        ItemJnlLine.CopyFromSalesHeader(SalesOrderHeader);        ItemJnlLine."Country/Region Code" := GetCountryCode(SalesOrderLine, SalesOrderHeader);        ItemJnlLine."Posting Date" := PurchHeader."Posting Date";        ItemJnlLine."Document Date" := PurchHeader."Document Date";        ItemJnlLine.CopyFromSalesLine(SalesOrderLine);        ItemJnlLine."Derived from Blanket Order" := SalesOrderLine."Blanket Order No." <> '';        ItemJnlLine."Applies-to Entry" := ItemLedgShptEntryNo;        ItemJnlLine.Quantity := QtyToBeShipped;        ItemJnlLine."Quantity (Base)" := QtyToBeShippedBase;        ItemJnlLine."Invoiced Quantity" := 0;        ItemJnlLine."Invoiced Qty. (Base)" := 0;        ItemJnlLine."Source Currency Code" := PurchHeader."Currency Code";        ItemJnlLine.Amount := SalesOrderLine.Amount * QtyToBeShipped / SalesOrderLine.Quantity;        if SalesOrderHeader."Currency Code" <> '' then begin            ItemJnlLine.Amount :=              Round(                CurrExchRate.ExchangeAmtFCYToLCY(                  SalesOrderHeader."Posting Date", SalesOrderHeader."Currency Code",                  ItemJnlLine.Amount, SalesOrderHeader."Currency Factor"));            ItemJnlLine."Discount Amount" :=              Round(                CurrExchRate.ExchangeAmtFCYToLCY(                  SalesOrderHeader."Posting Date", SalesOrderHeader."Currency Code",                  SalesOrderLine."Line Discount Amount", SalesOrderHeader."Currency Factor"));        end else begin            ItemJnlLine.Amount := Round(ItemJnlLine.Amount);            ItemJnlLine."Discount Amount" := SalesOrderLine."Line Discount Amount";        end;        OnAfterInitAssocItemJnlLine(ItemJnlLine, SalesOrderHeader, SalesOrderLine, PurchHeader, QtyToBeShipped);    end;    local procedure ReleasePurchDocument(var PurchaseHeader: Record "Purchase Header")    var        PurchaseHeaderCopy: Record "Purchase Header";        ReleasePurchaseDocument: Codeunit "Release Purchase Document";        LinesWereModified: Boolean;        PrevStatus: Enum "Purchase Document Status";        IsHandled: Boolean;    begin        if not (PurchaseHeader.Status = PurchaseHeader.Status::Open) or (PurchaseHeader.Status = PurchaseHeader.Status::"Pending Prepayment") then            exit;        PurchaseHeaderCopy := PurchaseHeader;        PrevStatus := PurchaseHeader.Status;        OnBeforeReleasePurchDoc(PurchaseHeader, PreviewMode);        LinesWereModified := ReleasePurchaseDocument.ReleasePurchaseHeader(PurchaseHeader, PreviewMode);        if LinesWereModified then            RefreshTempLines(PurchaseHeader, TempPurchLineGlobal);        TestStatusRelease(PurchaseHeader);        PurchaseHeader.Status := PrevStatus;        RestorePurchaseHeader(PurchaseHeader, PurchaseHeaderCopy);        OnAfterReleasePurchDoc(PurchaseHeader);        if not PreviewMode then begin            PurchaseHeader.Modify();            IsHandled := false;            OnReleasePurchDocumentOnBeforeDoCommit(PurchaseHeader, IsHandled);            if (not IsHandled) and (not SuppressCommit) then                Commit();        end;        IsHandled := false;        OnReleasePurchDocumentOnBeforeSetStatus(PurchaseHeader, IsHandled);        if not IsHandled then            PurchaseHeader.Status := PurchaseHeader.Status::Released;    end;    local procedure TestStatusRelease(PurchHeader: Record "Purchase Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestStatusRelease(PurchHeader, IsHandled);        if not IsHandled then            PurchHeader.TestField(Status, PurchHeader.Status::Released);    end;    /// <summary>    /// Checks for non-zero quantities (Quantity to Ship/Receive/Invoice) on the purchase line based on the document type    /// Check is carried out to ensure General Posting and VAT Postings setups that are used, are not blocked    /// </summary>    /// <remarks>    /// For line related to item tracking specifications are checked    /// For line related to charges check is performed to ensure line does not relate to a job    /// For line related to fixed assets fixed asset information is checked    /// For any other line type check is performed to ensure information related to FA is blank    /// If the line relates to a job, job task must be specified    /// </remarks>    /// <param name="PurchaseHeader">The purchase header of the document that is being posted.</param>    /// <param name="PurchaseLine">The purchase line of the document that is being posted.</param>    procedure TestPurchLine(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line")    var        DummyTrackingSpecification: Record "Tracking Specification";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestPurchLine(PurchaseLine, PurchaseHeader, SuppressCommit, IsHandled);        if not IsHandled then begin            case PurchaseLine.Type of                PurchaseLine.Type::Item:                    case PurchaseHeader."Document Type" of                        PurchaseHeader."Document Type"::Order, PurchaseHeader."Document Type"::Invoice:                            DummyTrackingSpecification.CheckItemTrackingQuantity(                              DATABASE::"Purchase Line", PurchaseLine."Document Type".AsInteger(), PurchaseLine."Document No.", PurchaseLine."Line No.",                              PurchaseLine."Qty. to Receive (Base)", PurchaseLine."Qty. to Invoice (Base)", PurchaseHeader.Receive, PurchaseHeader.Invoice);                        PurchaseHeader."Document Type"::"Credit Memo", PurchaseHeader."Document Type"::"Return Order":                            DummyTrackingSpecification.CheckItemTrackingQuantity(                              DATABASE::"Purchase Line", PurchaseLine."Document Type".AsInteger(), PurchaseLine."Document No.", PurchaseLine."Line No.",                              PurchaseLine."Return Qty. to Ship (Base)", PurchaseLine."Qty. to Invoice (Base)", PurchaseHeader.Ship, PurchaseHeader.Invoice);                        else                            OnTestPurchLineOnTypeCaseOnDocumentTypeCaseElse(PurchaseHeader, PurchaseLine);                    end;                PurchaseLine.Type::"Charge (Item)":                    TestPurchLineItemCharge(PurchaseLine);                PurchaseLine.Type::"Fixed Asset":                    TestPurchLineFixedAsset(PurchaseLine);                else                    TestPurchLineOthers(PurchaseLine);            end;            TestPurchLineJob(PurchaseLine);            case PurchaseHeader."Document Type" of                PurchaseHeader."Document Type"::Order:                    PurchaseLine.TestField("Return Qty. to Ship", 0, ErrorInfo.Create());                PurchaseHeader."Document Type"::Invoice:                    begin                        IsHandled := false;                        OnTestPurchLineOnBeforeTestFieldQtyToReceive(PurchaseLine, IsHandled);                        if not IsHandled then                            if not PurchaseLine.IsMatchedToReceiptOrOrder() then                                PurchaseLine.TestField("Qty. to Receive", PurchaseLine.Quantity, ErrorInfo.Create());                        PurchaseLine.TestField("Return Qty. to Ship", 0, ErrorInfo.Create());                        PurchaseLine.TestField("Qty. to Invoice", PurchaseLine.Quantity, ErrorInfo.Create());                    end;                PurchaseHeader."Document Type"::"Return Order":                    PurchaseLine.TestField("Qty. to Receive", 0, ErrorInfo.Create());                PurchaseHeader."Document Type"::"Credit Memo":                    begin                        IsHandled := false;                        OnTestPurchLineOnBeforeTestFieldReturnQtyToShip(PurchaseLine, IsHandled);                        if not IsHandled then                            if PurchaseLine."Return Shipment No." = '' then                                PurchaseLine.TestField("Return Qty. to Ship", PurchaseLine.Quantity, ErrorInfo.Create());                        IsHandled := false;                        OnTestPurchLineOnBeforetestFieldQtyToReceive(PurchaseLine, IsHandled);                        if not IsHandled then                            PurchaseLine.TestField("Qty. to Receive", 0, ErrorInfo.Create());                        PurchaseLine.TestField("Qty. to Invoice", PurchaseLine.Quantity, ErrorInfo.Create());                    end;            end;            if PurchaseLine."Blanket Order No." <> '' then                PurchaseLine.TestField("Blanket Order Line No.", ErrorInfo.Create());        end;        CheckBlockedPostingGroups(PurchaseLine);        OnAfterTestPurchLine(PurchaseHeader, PurchaseLine, WhseReceive, WhseShip);    end;    /// <summary>    /// Check is carried out to ensure General Posting and VAT Postings setups that are used on the line, are not blocked    /// </summary>    /// <remarks>    /// The check is only performed for non-empty type lines (i.e. G/L Account, Item, etc.)    /// </remarks>    /// <param name="PurchaseLine">The purchase line of the document that is being posted.</param>    procedure CheckBlockedPostingGroups(PurchaseLine: Record "Purchase Line")    var        GeneralPostingSetup: Record "General Posting Setup";        VATPostingSetup: Record "VAT Posting Setup";        ForwardLinkMgt: Codeunit "Forward Link Mgt.";    begin        if not PurchaseLine.HasTypeToFillMandatoryFields() then            exit;        if GeneralPostingSetup.Get(PurchaseLine."Gen. Bus. Posting Group", PurchaseLine."Gen. Prod. Posting Group") then            if GeneralPostingSetup.Blocked then                ErrorMessageMgt.LogContextFieldError(                  PurchaseLine.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(PurchaseLine."VAT Bus. Posting Group", PurchaseLine."VAT Prod. Posting Group") then            if VATPostingSetup.Blocked then                ErrorMessageMgt.LogContextFieldError(                    PurchaseLine.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 TestPurchLineItemCharge(PurchaseLine: Record "Purchase Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestPurchLineItemCharge(PurchaseLine, IsHandled);        if IsHandled then            exit;        if (PurchaseLine.Amount = 0) and (PurchaseLine.Quantity <> 0) then            Error(ErrorInfo.Create(StrSubstNo(ItemChargeZeroAmountErr, PurchaseLine."No."), true, PurchaseLine));        PurchaseLine.TestField("Job No.", '', ErrorInfo.Create());    end;    local procedure TestPurchLineJob(PurchaseLine: Record "Purchase Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestPurchLineJob(PurchaseLine, IsHandled);        if IsHandled then            exit;        if PurchaseLine."Job No." <> '' then            PurchaseLine.TestField("Job Task No.", ErrorInfo.Create());    end;    local procedure TestPurchLineFixedAsset(PurchaseLine: Record "Purchase Line")    var        FixedAsset: Record "Fixed Asset";        DeprBook: Record "Depreciation Book";        FASetup: Record "FA Setup";        FADepreciationBook: Record "FA Depreciation Book";        FACheckConsistency: Codeunit "FA Check Consistency";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestPurchLineFixedAsset(PurchaseLine, IsHandled);        if IsHandled then            exit;        if (PurchaseLine."Document Type" = PurchaseLine."Document Type"::Order) and           (PurchaseLine."Qty. to Invoice (Base)" = 0)        then            exit;        PurchaseLine.TestField("Job No.", '', ErrorInfo.Create());        PurchaseLine.TestField("Depreciation Book Code", ErrorInfo.Create());        PurchaseLine.TestField("FA Posting Type", ErrorInfo.Create());        FixedAsset.Get(PurchaseLine."No.");        FixedAsset.TestField("Budgeted Asset", false, ErrorInfo.Create());        DeprBook.Get(PurchaseLine."Depreciation Book Code");        if FADepreciationBook.Get(PurchaseLine."No.", PurchaseLine."Depreciation Book Code") then            FACheckConsistency.CheckDisposalDate(FADepreciationBook, FixedAsset);        if PurchaseLine."Budgeted FA No." <> '' then begin            FixedAsset.Get(PurchaseLine."Budgeted FA No.");            FixedAsset.TestField("Budgeted Asset", true, ErrorInfo.Create());        end;        if PurchaseLine."FA Posting Type" = PurchaseLine."FA Posting Type"::Maintenance then begin            PurchaseLine.TestField("Insurance No.", '', ErrorInfo.Create());            PurchaseLine.TestField("Depr. until FA Posting Date", false, ErrorInfo.Create());            PurchaseLine.TestField("Depr. Acquisition Cost", false, ErrorInfo.Create());            DeprBook.TestField("G/L Integration - Maintenance", true, ErrorInfo.Create());        end;        if PurchaseLine."FA Posting Type" = PurchaseLine."FA Posting Type"::"Acquisition Cost" then begin            PurchaseLine.TestField("Maintenance Code", '', ErrorInfo.Create());            DeprBook.TestField("G/L Integration - Acq. Cost", true, ErrorInfo.Create());        end;        if PurchaseLine."Insurance No." <> '' then begin            FASetup.Get();            FASetup.TestField("Insurance Depr. Book", PurchaseLine."Depreciation Book Code", ErrorInfo.Create());        end;    end;    local procedure TestPurchLineOthers(PurchaseLine: Record "Purchase Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestPurchLineOthers(PurchaseLine, IsHandled);        if IsHandled then            exit;        PurchaseLine.TestField("Depreciation Book Code", '', ErrorInfo.Create());        PurchaseLine.TestField("FA Posting Type", 0, ErrorInfo.Create());        PurchaseLine.TestField("Maintenance Code", '', ErrorInfo.Create());        PurchaseLine.TestField("Insurance No.", '', ErrorInfo.Create());        PurchaseLine.TestField("Depr. until FA Posting Date", false, ErrorInfo.Create());        PurchaseLine.TestField("Depr. Acquisition Cost", false, ErrorInfo.Create());        PurchaseLine.TestField("Budgeted FA No.", '', ErrorInfo.Create());        PurchaseLine.TestField("FA Posting Date", 0D, ErrorInfo.Create());        PurchaseLine.TestField("Salvage Value", 0, ErrorInfo.Create());        PurchaseLine.TestField("Duplicate in Depreciation Book", '', ErrorInfo.Create());        PurchaseLine.TestField("Use Duplication List", false, ErrorInfo.Create());    end;    /// <summary>    /// Wrapper procedure to update associated Drop Shipment Sales Orders    /// Shipping information is updated on the associated Sales Order    /// Reservation entries of associated Sales Order are updated    /// Quantities that relate to shipping are update on associated Sales Order Lines    /// </summary>    /// <param name="TempDropShptPostBuffer">Temporary record that store associated drop shipments.</param>    procedure UpdateAssocOrder(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    var        DummyPurchaseHeader: Record "Purchase Header";    begin        UpdateAssociatedSalesOrder(TempDropShptPostBuffer, DummyPurchaseHeader);    end;    local procedure UpdateAssociatedSalesOrder(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; PurchaseHeader: Record "Purchase Header")    var        SalesSetup: Record "Sales & Receivables Setup";        SalesOrderHeader: Record "Sales Header";        SalesOrderLine: Record "Sales Line";        SalesLineReserve: Codeunit "Sales Line-Reserve";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateAssocOrder(TempDropShptPostBuffer, IsHandled, SuppressCommit, PurchaseHeader);        if IsHandled then            exit;        TempDropShptPostBuffer.Reset();        if TempDropShptPostBuffer.IsEmpty() then            exit;        SalesSetup.Get();        if TempDropShptPostBuffer.FindSet() then begin            repeat                SalesOrderHeader.Get(                  SalesOrderHeader."Document Type"::Order,                  TempDropShptPostBuffer."Order No.");                CheckAndUpdateAssocOrderPostingDate(SalesOrderHeader, PurchaseHeader."Posting Date");                SalesOrderHeader."Last Shipping No." := SalesOrderHeader."Shipping No.";                SalesOrderHeader."Shipping No." := '';                SalesOrderHeader.Modify();                OnUpdateAssocOrderOnAfterSalesOrderHeaderModify(SalesOrderHeader, SalesSetup);                SalesLineReserve.UpdateItemTrackingAfterPosting(SalesOrderHeader);                TempDropShptPostBuffer.SetRange("Order No.", TempDropShptPostBuffer."Order No.");                repeat                    SalesOrderLine.Get(                      SalesOrderLine."Document Type"::Order,                      TempDropShptPostBuffer."Order No.", TempDropShptPostBuffer."Order Line No.");                    SalesOrderLine."Quantity Shipped" := SalesOrderLine."Quantity Shipped" + TempDropShptPostBuffer.Quantity;                    SalesOrderLine."Qty. Shipped (Base)" := SalesOrderLine."Qty. Shipped (Base)" + TempDropShptPostBuffer."Quantity (Base)";                    OnUpdateAssociatedSalesOrderBeforeInitOutstanding(TempDropShptPostBuffer, SalesOrderLine, SalesOrderHeader);                    SalesOrderLine.InitOutstanding();                    if SalesSetup."Default Quantity to Ship" <> SalesSetup."Default Quantity to Ship"::Blank then                        SalesOrderLine.InitQtyToShip()                    else begin                        SalesOrderLine."Qty. to Ship" := 0;                        SalesOrderLine."Qty. to Ship (Base)" := 0;                    end;                    OnUpdateAssocOrderOnBeforeSalesOrderLineModify(SalesOrderLine, TempDropShptPostBuffer, SalesOrderHeader);                    SalesOrderLine.Modify();                    OnUpdateAssocOrderOnAfterSalesOrderLineModify(SalesOrderLine, TempDropShptPostBuffer, SalesOrderHeader, SalesShptHeader);                until TempDropShptPostBuffer.Next() = 0;                TempDropShptPostBuffer.SetRange("Order No.");                OnUpdateAssocOrderOnAfterOrderNoClearFilter(TempDropShptPostBuffer);            until TempDropShptPostBuffer.Next() = 0;            OnUpdateAssociatedSalesOrderOnBeforeClearTempDropShptPostBuffer(TempDropShptPostBuffer);            TempDropShptPostBuffer.DeleteAll();        end;    end;    local procedure UpdateAssosOrderPostingNos(PurchaseHeader: Record "Purchase Header") DropShipment: Boolean    var        TempPurchaseLine: Record "Purchase Line" temporary;        SalesOrderHeader: Record "Sales Header";        NoSeries: Codeunit "No. Series";        ReleaseSalesDocument: Codeunit "Release Sales Document";        IsHandled: Boolean;    begin        ResetTempLines(TempPurchaseLine);        TempPurchaseLine.SetFilter("Sales Order Line No.", '<>0');        DropShipment := not TempPurchaseLine.IsEmpty();        IsHandled := false;        OnBeforeUpdateAssosOrderPostingNos(TempPurchaseLine, PurchaseHeader, DropShipment, IsHandled, PreviewMode);        if IsHandled then            exit(DropShipment);        TempPurchaseLine.SetFilter("Qty. to Receive", '<>0');        if DropShipment and PurchaseHeader.Receive then            if TempPurchaseLine.FindSet() then                repeat                    if SalesOrderHeader."No." <> TempPurchaseLine."Sales Order No." then begin                        SalesOrderHeader.Get(SalesOrderHeader."Document Type"::Order, TempPurchaseLine."Sales Order No.");                        IsHandled := false;                        OnUpdateAssosOrderPostingNosOnBeforeTestFieldBilltoCustomerNo(SalesOrderHeader, IsHandled);                        if not IsHandled then                            SalesOrderHeader.TestField("Bill-to Customer No.");                        SalesOrderHeader.Ship := true;                        OnUpdateAssosOrderPostingNosOnBeforeReleaseSalesHeader(PurchaseHeader, SalesOrderHeader);                        ReleaseSalesDocument.ReleaseSalesHeader(SalesOrderHeader, PreviewMode);                        if SalesOrderHeader."Shipping No." = '' then begin                            SalesOrderHeader.TestField("Shipping No. Series");                            SalesOrderHeader."Shipping No." :=                                NoSeries.GetNextNo(SalesOrderHeader."Shipping No. Series", PurchaseHeader."Posting Date");                            SalesOrderHeader.Modify();                        end;                        OnUpdateAssosOrderPostingNosOnAfterReleaseSalesHeader(PurchaseHeader, SalesOrderHeader);                    end;                until TempPurchaseLine.Next() = 0;        exit(DropShipment);    end;    /// <summary>    /// Update Posting Date on an associated drop shipment Sales Order    /// </summary>    /// <remarks>    /// Document Date is being retained after updating Posting Date     /// </remarks>    /// <param name="SalesHeader">Drop Shipment Sales Order related to current purchase document</param>    /// <param name="PostingDate">New posting Date</param>    procedure CheckAndUpdateAssocOrderPostingDate(var SalesHeader: Record "Sales Header"; PostingDate: Date)    var        SalesReceivablesSetup: Record "Sales & Receivables Setup";        ReleaseSalesDocument: Codeunit "Release Sales Document";        OriginalDocumentDate: Date;    begin        if (PostingDate <> 0D) and (SalesHeader."Posting Date" <> PostingDate) then begin            ReleaseSalesDocument.Reopen(SalesHeader);            ReleaseSalesDocument.SetSkipCheckReleaseRestrictions();            OriginalDocumentDate := SalesHeader."Document Date";            SalesHeader.SetHideValidationDialog(true);            SalesHeader.Validate("Posting Date", PostingDate);            SalesReceivablesSetup.SetLoadFields("Link Doc. Date To Posting Date");            SalesReceivablesSetup.GetRecordOnce();            if SalesReceivablesSetup."Link Doc. Date To Posting Date" then                SalesHeader.Validate("Document Date", PostingDate)            else begin                OnCheckAndUpdateAssocOrderPostingDateOnBeforeValidateDocumentDate(SalesHeader, OriginalDocumentDate);                SalesHeader.Validate("Document Date", OriginalDocumentDate);            end;            ReleaseSalesDocument.Run(SalesHeader);        end;    end;    local procedure UpdateAfterPosting(PurchHeader: Record "Purchase Header")    var        TempPurchLine: Record "Purchase Line" temporary;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateAfterPosting(PurchHeader, SuppressCommit, IsHandled);        if IsHandled then            exit;        ResetTempLines(TempPurchLine);        TempPurchLine.SetFilter("Blanket Order Line No.", '<>0');        if TempPurchLine.FindSet() then            repeat                UpdateBlanketOrderLine(TempPurchLine, PurchHeader.Receive, PurchHeader.Ship, PurchHeader.Invoice);            until TempPurchLine.Next() = 0;    end;    local procedure UpdateLastPostingNos(var PurchHeader: Record "Purchase Header")    begin        if PurchHeader.Receive then begin            PurchHeader."Last Receiving No." := PurchHeader."Receiving No.";            PurchHeader."Receiving No." := '';        end;        if PurchHeader.Invoice then begin            PurchHeader."Last Posting No." := PurchHeader."Posting No.";            PurchHeader."Posting No." := '';        end;        if PurchHeader.Ship then begin            PurchHeader."Last Return Shipment No." := PurchHeader."Return Shipment No.";            PurchHeader."Return Shipment No." := '';        end;        OnAfterUpdateLastPostingNos(PurchHeader);    end;    local procedure UpdatePostingNos(var PurchHeader: Record "Purchase Header") ModifyHeader: Boolean    var        NoSeries: Codeunit "No. Series";        IsHandled: Boolean;        ShouldUpdateReceivingNo: Boolean;    begin        IsHandled := false;        OnBeforeUpdatePostingNos(PurchHeader, ModifyHeader, SuppressCommit, IsHandled, DateOrderSeriesUsed);        if IsHandled then            exit;        UpdateReceivingNoTelemetry(PurchHeader);        ShouldUpdateReceivingNo := PurchHeader.Receive and (PurchHeader."Receiving No." = '');        OnUpdatePostingNosOnAfterCalcShouldUpdateReceivingNo(PurchHeader, PreviewMode, ModifyHeader, ShouldUpdateReceivingNo);        if ShouldUpdateReceivingNo then            if (PurchHeader."Document Type" = PurchHeader."Document Type"::Order) or               ((PurchHeader."Document Type" = PurchHeader."Document Type"::Invoice) and PurchSetup."Receipt on Invoice")            then                if not PreviewMode then begin                    ResetPostingNoSeriesFromSetup(PurchHeader."Receiving No. Series", PurchSetup."Posted Receipt Nos.");                    PurchHeader.TestField("Receiving No. Series");                    PurchHeader."Receiving No." := NoSeries.GetNextNo(PurchHeader."Receiving No. Series", PurchHeader."Posting Date");                    if NoSeries.IsNoSeriesInDateOrder(PurchHeader."Receiving No. Series") then                        DateOrderSeriesUsed := true;                    ModifyHeader := true;                    // Check for posting conflicts.                    if PurchRcptHeader.Get(PurchHeader."Receiving No.") then                        Error(PurchRcptHeaderConflictErr, PurchHeader."Receiving No.");                end;        if PurchHeader.Ship and (PurchHeader."Return Shipment No." = '') then            if (PurchHeader."Document Type" = PurchHeader."Document Type"::"Return Order") or               ((PurchHeader."Document Type" = PurchHeader."Document Type"::"Credit Memo") and PurchSetup."Return Shipment on Credit Memo")            then                if not PreviewMode then begin                    ResetPostingNoSeriesFromSetup(PurchHeader."Return Shipment No. Series", PurchSetup."Posted Return Shpt. Nos.");                    PurchHeader.TestField("Return Shipment No. Series");                    PurchHeader."Return Shipment No." := NoSeries.GetNextNo(PurchHeader."Return Shipment No. Series", PurchHeader."Posting Date");                    if NoSeries.IsNoSeriesInDateOrder(PurchHeader."Return Shipment No. Series") then                        DateOrderSeriesUsed := true;                    ModifyHeader := true;                    OnUpdatePostingNosOnAfterSetReturnShipmentNoFromNos(PurchHeader);                    // Check for posting conflicts.                    if ReturnShptHeader.Get(PurchHeader."Return Shipment No.") then                        Error(ReturnShptHeaderConflictErr, PurchHeader."Return Shipment No.");                end;        IsHandled := false;        OnUpdatePostingNosOnBeforeUpdatePostingNo(PurchHeader, PreviewMode, ModifyHeader, IsHandled);        if not IsHandled then            if PurchHeader.Invoice and (PurchHeader."Posting No." = '') then begin                if (PurchHeader."No. Series" <> '') or                   (PurchHeader."Document Type" in [PurchHeader."Document Type"::Order, PurchHeader."Document Type"::"Return Order"])                then begin                    if PurchHeader."Document Type" in [PurchHeader."Document Type"::"Return Order"] then                        ResetPostingNoSeriesFromSetup(PurchHeader."Posting No. Series", PurchSetup."Posted Credit Memo Nos.")                    else                        if (PurchHeader."Document Type" <> PurchHeader."Document Type"::"Credit Memo") then                            ResetPostingNoSeriesFromSetup(PurchHeader."Posting No. Series", PurchSetup."Posted Invoice Nos.");                    if PurchHeader."Document Type" = PurchHeader."Document Type"::"Credit Memo" then                        if (PurchSetup."Posted Credit Memo Nos." <> '') and (PurchHeader."Posting No. Series" = '') then                            CheckDefaultNoSeries(PurchSetup."Posted Credit Memo Nos.");                    PurchHeader.TestField("Posting No. Series");                end;                if (PurchHeader."No. Series" <> PurchHeader."Posting No. Series") or                   (PurchHeader."Document Type" in [PurchHeader."Document Type"::Order, PurchHeader."Document Type"::"Return Order"])                then                    if not PreviewMode then begin                        IsHandled := false;                        OnUpdatePostingNosOnInvoiceOnBeforeSetPostingNo(PurchHeader, IsHandled);                        if not IsHandled then                            PurchHeader."Posting No." := NoSeries.GetNextNo(PurchHeader."Posting No. Series", PurchHeader."Posting Date");                        if NoSeries.IsNoSeriesInDateOrder(PurchHeader."Posting No. Series") then                            DateOrderSeriesUsed := true;                        ModifyHeader := true;                    end;                // Check for posting conflicts.                if not PreviewMode then                    if PurchHeader."Document Type" in [PurchHeader."Document Type"::Order, PurchHeader."Document Type"::Invoice] then begin                        if PurchInvHeader.Get(PurchHeader."Posting No.") then                            Error(PurchInvHeaderConflictErr, PurchHeader."Posting No.");                    end else                        if PurchCrMemoHeader.Get(PurchHeader."Posting No.") then                            Error(PurchCrMemoHeaderConflictErr, PurchHeader."Posting No.");            end;        OnAfterUpdatePostingNos(PurchHeader, SuppressCommit, PreviewMode, ModifyHeader);    end;    local procedure ResetPostingNoSeriesFromSetup(var PostingNoSeries: Code[20]; SetupNoSeries: Code[20])    begin        if (PostingNoSeries = '') and (SetupNoSeries <> '') then            PostingNoSeries := SetupNoSeries;    end;    local procedure UpdatePurchLineBeforePost(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line")    var        InitQtyToInvoiceNeeded: Boolean;    begin        OnBeforeUpdatePurchLineBeforePost(PurchLine, PurchHeader, WhseShip, WhseReceive, RoundingLineInserted, SuppressCommit);        if not (PurchHeader.Receive or RoundingLineInserted) then begin            PurchLine."Qty. to Receive" := 0;            PurchLine."Qty. to Receive (Base)" := 0;        end;        if not (PurchHeader.Ship or RoundingLineInserted) then begin            PurchLine."Return Qty. to Ship" := 0;            PurchLine."Return Qty. to Ship (Base)" := 0;        end;        if (PurchHeader."Document Type" = PurchHeader."Document Type"::Invoice) and PurchLine.IsMatchedToReceiptOrOrder() then begin            PurchLine."Quantity Received" := PurchLine.Quantity;            PurchLine."Qty. Received (Base)" := PurchLine."Quantity (Base)";            PurchLine."Qty. to Receive" := 0;            PurchLine."Qty. to Receive (Base)" := 0;        end;        if (PurchHeader."Document Type" = PurchHeader."Document Type"::"Credit Memo") and (PurchLine."Return Shipment No." <> '')        then begin            PurchLine."Return Qty. Shipped" := PurchLine.Quantity;            PurchLine."Return Qty. Shipped (Base)" := PurchLine."Quantity (Base)";            PurchLine."Return Qty. to Ship" := 0;            PurchLine."Return Qty. to Ship (Base)" := 0;        end;        if PurchHeader.Invoice then begin            InitQtyToInvoiceNeeded := Abs(PurchLine."Qty. to Invoice") > Abs(PurchLine.MaxQtyToInvoice());            OnUpdatePurchLineBeforePostOnAfterCalcInitQtyToInvoiceNeeded(PurchHeader, PurchLine, InitQtyToInvoiceNeeded);            if InitQtyToInvoiceNeeded then                PurchLine.InitQtyToInvoice();        end else begin            PurchLine."Qty. to Invoice" := 0;            PurchLine."Qty. to Invoice (Base)" := 0;        end;        OnAfterUpdatePurchLineBeforePost(PurchLine, WhseShip, WhseReceive, PurchHeader, RoundingLineInserted);    end;    local procedure UpdateWhseDocuments()    begin        if WhseReceive then begin            WhsePostRcpt.PostUpdateWhseDocuments(WhseRcptHeader);            TempWhseRcptHeader.Delete();            OnUpdateWhseDocumentsOnAfterUpdateWhseRcpt(WhseRcptHeader);        end;        if WhseShip then begin            WhsePostShpt.PostUpdateWhseDocuments(WhseShptHeader);            TempWhseShptHeader.Delete();            OnUpdateWhseDocumentsOnAfterUpdateWhseShpt(WhseShptHeader);        end;    end;    local procedure DeleteAfterPosting(var PurchHeader: Record "Purchase Header")    var        PurchCommentLine: Record "Purch. Comment Line";        PurchLine: Record "Purchase Line";        TempPurchLine: Record "Purchase Line" temporary;        WarehouseRequest: Record "Warehouse Request";        SkipDelete: Boolean;    begin        OnBeforeDeleteAfterPosting(PurchHeader, PurchInvHeader, PurchCrMemoHeader, PurchRcptHeader, SkipDelete, SuppressCommit, TempPurchLine, TempPurchLineGlobal, GenJnlPostLine);        if SkipDelete then            exit;        if PurchHeader.HasLinks then            PurchHeader.DeleteLinks();        WarehouseRequest.DeleteRequest(DATABASE::"Purchase Line", PurchHeader."Document Type".AsInteger(), PurchHeader."No.");        PurchHeader.Delete();        PurchLineReserve.DeleteInvoiceSpecFromHeader(PurchHeader);        ResetTempLines(TempPurchLine);        if TempPurchLine.FindFirst() then            repeat                if TempPurchLine."Deferral Code" <> '' then                    DeferralUtilities.RemoveOrSetDeferralSchedule(                        '', "Deferral Document Type"::Purchase.AsInteger(), '', '', TempPurchLine."Document Type".AsInteger(),                        TempPurchLine."Document No.", TempPurchLine."Line No.", 0, 0D, TempPurchLine.Description, '', true);                if TempPurchLine.HasLinks then                    TempPurchLine.DeleteLinks();            until TempPurchLine.Next() = 0;        MatchedOrderLineMgmt.DeleteAllMatchedOrderLines(PurchHeader);        PurchLine.SetRange("Document Type", PurchHeader."Document Type");        PurchLine.SetRange("Document No.", PurchHeader."No.");        OnBeforePurchLineDeleteAll(PurchLine, SuppressCommit, TempPurchLine);        PurchLine.DeleteAll();        DeleteItemChargeAssgnt(PurchHeader);        PurchCommentLine.DeleteComments(PurchHeader."Document Type".AsInteger(), PurchHeader."No.");        OnAfterDeleteAfterPosting(PurchHeader, PurchInvHeader, PurchCrMemoHeader, SuppressCommit);    end;    local procedure FinalizePosting(var PurchHeader: Record "Purchase Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; EverythingInvoiced: Boolean)    var        TempPurchLine: Record "Purchase Line" temporary;        GenJnlPostPreview: Codeunit "Gen. Jnl.-Post Preview";        ArchiveManagement: Codeunit ArchiveManagement;        IsHandled: Boolean;    begin        OnBeforeFinalizePosting(PurchHeader, TempPurchLineGlobal, EverythingInvoiced, SuppressCommit, GenJnlPostLine);        if (PurchHeader."Document Type" in [PurchHeader."Document Type"::Order, PurchHeader."Document Type"::"Return Order"]) and           (not EverythingInvoiced)        then begin            PurchHeader.Modify();            InsertTrackingSpecification(PurchHeader);            PostUpdateOrderLine(PurchHeader);            UpdateAssociatedSalesOrder(TempDropShptPostBuffer, PurchHeader);            IsHandled := false;            OnFinalizePostingOnBeforeUpdateWhseDocuments(PurchHeader, WhseRcptHeader, TempWhseRcptHeader, WhseShptHeader, TempWhseShptHeader, WhseReceive, WhseShip, IsHandled);            if not IsHandled then                if not PreviewMode then                    UpdateWhseDocuments();            WhsePurchRelease.Release(PurchHeader);            UpdateItemChargeAssgnt(PurchHeader);            OnFinalizePostingOnAfterUpdateItemChargeAssgnt(PurchHeader, TempDropShptPostBuffer, EverythingInvoiced, TempPurchLine, TempPurchLineGlobal, GenJnlPostLine);        end else begin            OnFinalizePostingOnBeforeInsertTrackingSpecification(TempDropShptPostBuffer, PurchHeader, TempTrackingSpecification, EverythingInvoiced, TempPurchLine, TempPurchLineGlobal);            case PurchHeader."Document Type" of                PurchHeader."Document Type"::Invoice:                    begin                        PostUpdateInvoiceLine(PurchHeader);                        InsertTrackingSpecification(PurchHeader);                        PostUpdateOrderNo(PurchInvHeader);                    end;                PurchHeader."Document Type"::"Credit Memo":                    begin                        PostUpdateCreditMemoLine(PurchHeader);                        InsertTrackingSpecification(PurchHeader);                        PostUpdateOrderNo(PurchCrMemoHeader);                    end;                else begin                    UpdateAssociatedSalesOrder(TempDropShptPostBuffer, PurchHeader);                    if DropShipOrder then                        InsertTrackingSpecification(PurchHeader);                    ResetTempLines(TempPurchLine);                    TempPurchLine.SetFilter("Prepayment %", '<>0');                    if TempPurchLine.FindSet() then                        repeat                            DecrementPrepmtAmtInvLCY(                              PurchHeader, TempPurchLine, TempPurchLine."Prepmt. Amount Inv. (LCY)", TempPurchLine."Prepmt. VAT Amount Inv. (LCY)");                        until TempPurchLine.Next() = 0;                end;            end;            IsHandled := false;            OnFinalizePostingOnBeforeUpdateAfterPosting(PurchHeader, TempDropShptPostBuffer, EverythingInvoiced, IsHandled, TempPurchLine);            if not IsHandled then begin                UpdateAfterPosting(PurchHeader);                if not PreviewMode then                    UpdateWhseDocuments();                if not OrderArchived then                    ArchiveManagement.AutoArchivePurchDocument(PurchHeader);                DeleteApprovalEntries(PurchHeader);                if not PreviewMode then                    DeleteAfterPosting(PurchHeader);            end;        end;        OnFinalizePostingOnBeforeInsertValueEntryRelation(PurchHeader, PurchInvHeader, PurchCrMemoHeader);        InsertValueEntryRelation();        OnAfterFinalizePostingOnBeforeCommit(          PurchHeader, PurchRcptHeader, PurchInvHeader, PurchCrMemoHeader, ReturnShptHeader, GenJnlPostLine, PreviewMode, SuppressCommit, EverythingInvoiced);        if PreviewMode and (CalledBy = 0) then begin            if GuiAllowed() and not HideProgressWindow then                Window.Close();            GenJnlPostPreview.ThrowError();        end;        IsHandled := false;        OnFinalizePostingOnBeforeCommit(PreviewMode, IsHandled);        if not IsHandled then            if not (InvtPickPutaway or SuppressCommit or PreviewMode) then                Commit();        if GuiAllowed() and not HideProgressWindow then            Window.Close();        OnAfterFinalizePosting(          PurchHeader, PurchRcptHeader, PurchInvHeader, PurchCrMemoHeader, ReturnShptHeader, GenJnlPostLine, PreviewMode, SuppressCommit);        ClearPostBuffers();    end;    local procedure DeleteApprovalEntries(var PurchaseHeader: Record "Purchase Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeDeleteApprovalEntries(PurchaseHeader, IsHandled, PurchInvHeader, PurchCrMemoHeader);        if IsHandled then            exit;        ApprovalsMgmt.DeleteApprovalEntries(PurchaseHeader.RecordId());        OnAfterDeleteApprovalEntries(PurchaseHeader, PurchInvHeader, PurchCrMemoHeader, PurchRcptHeader);    end;    /// <summary>    /// Gets currency rounding precision.    /// If currency is not set rounding precision from General Ledger Setup is used.    /// </summary>    /// <param name="CurrencyCode">Currency Code of the purchase document</param>    procedure GetCurrency(CurrencyCode: Code[10])    begin        Currency.Initialize(CurrencyCode, true);        OnAfterGetCurrency(CurrencyCode, Currency);    end;    /// <summary>    /// Procedure calculates and divides Amounts, VAT amounts and discounts associated with purchase line    /// The procedure is intended to make sure amounts, discounts and VAT are correct before posting and calculating sum of all purchase line for the document    /// When calculating, prepayments is taken into consideration    /// Non-deductible VAT is being calculated    /// If Deferral Code is specified on the purchase line deferrals are being calculated    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    /// <param name="QtyType">The QtyType to determine "Inv. Discount Amount". When QtyType = Invoicing "Inv. Disc. Amount to Invoice" is used, for other options the amount is calculated.</param>    /// <param name="PurchLineQty">Quantity on the purchase line</param>    /// <param name="TempVATAmountLine">Temporary record storing VAT information related to purchase line</param>    /// <param name="TempVATAmountLineRemainder">Temporary record storing not yet divided VAT information related to purchase line</param>    procedure DivideAmount(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; QtyType: Option General,Invoicing,Shipping; PurchLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary)    var        OriginalDeferralAmount: Decimal;        IsHandled: Boolean;    begin        if RoundingLineInserted and (RoundingLineNo = PurchLine."Line No.") then            exit;        IsHandled := false;        OnBeforeDivideAmount(PurchHeader, PurchLine, QtyType, PurchLineQty, TempVATAmountLine, TempVATAmountLineRemainder, IsHandled);        if IsHandled then            exit;        if (PurchLineQty = 0) or (PurchLine."Direct Unit Cost" = 0) then begin            PurchLine."Line Amount" := 0;            PurchLine."Line Discount Amount" := 0;            PurchLine."Inv. Discount Amount" := 0;            PurchLine."VAT Base Amount" := 0;            PurchLine.Amount := 0;            PurchLine."Amount Including VAT" := 0;            OnDivideAmountOnAfterClearAmounts(PurchHeader, PurchLine, PurchLineQty);        end else begin            OriginalDeferralAmount := PurchLine.GetDeferralAmount();            IsHandled := false;            OnDivideAmountOnBeforeTempVATAmountLineGet(PurchLine, TempVATAmountLine, IsHandled);            if not IsHandled then                TempVATAmountLine.Get(                    PurchLine."VAT Identifier", PurchLine."VAT Calculation Type", PurchLine."Tax Group Code", PurchLine."Use Tax", PurchLine."Line Amount" >= 0);            if PurchLine."VAT Calculation Type" = PurchLine."VAT Calculation Type"::"Sales Tax" then                PurchLine."VAT %" := TempVATAmountLine."VAT %";            TempVATAmountLineRemainder := TempVATAmountLine;            if not TempVATAmountLineRemainder.Find() then begin                TempVATAmountLineRemainder.Init();                TempVATAmountLineRemainder.Insert();            end;            CalcLineAmountAndLineDiscountAmount(PurchHeader, PurchLine, PurchLineQty);            OnDivideAmountOnAfterCalcLineAmountAndLineDiscountAmount(PurchHeader, PurchLine, PurchLineQty);            if PurchLine."Allow Invoice Disc." and (TempVATAmountLine."Inv. Disc. Base Amount" <> 0) then                if QtyType = QtyType::Invoicing then                    PurchLine."Inv. Discount Amount" := PurchLine."Inv. Disc. Amount to Invoice"                else begin                    TempVATAmountLineRemainder."Invoice Discount Amount" :=                      TempVATAmountLineRemainder."Invoice Discount Amount" +                      TempVATAmountLine."Invoice Discount Amount" * PurchLine."Line Amount" /                      TempVATAmountLine."Inv. Disc. Base Amount";                    PurchLine."Inv. Discount Amount" :=                      Round(                        TempVATAmountLineRemainder."Invoice Discount Amount", Currency."Amount Rounding Precision");                    TempVATAmountLineRemainder."Invoice Discount Amount" :=                      TempVATAmountLineRemainder."Invoice Discount Amount" - PurchLine."Inv. Discount Amount";                end;            if PurchHeader."Prices Including VAT" then begin                if (TempVATAmountLine.CalcLineAmount() = 0) or (PurchLine."Line Amount" = 0) then begin                    TempVATAmountLineRemainder."VAT Amount" := 0;                    TempVATAmountLineRemainder."Amount Including VAT" := 0;                end else begin                    TempVATAmountLineRemainder."VAT Amount" +=                      TempVATAmountLine."VAT Amount" * PurchLine.CalcLineAmount() / TempVATAmountLine.CalcLineAmount();                    TempVATAmountLineRemainder."Amount Including VAT" +=                      TempVATAmountLine."Amount Including VAT" * PurchLine.CalcLineAmount() / TempVATAmountLine.CalcLineAmount();                end;                CalculateAmountsInclVAT(PurchHeader, PurchLine, TempVATAmountLine, TempVATAmountLineRemainder);                TempVATAmountLineRemainder."Amount Including VAT" :=                  TempVATAmountLineRemainder."Amount Including VAT" - PurchLine."Amount Including VAT";                TempVATAmountLineRemainder."VAT Amount" :=                  TempVATAmountLineRemainder."VAT Amount" - PurchLine."Amount Including VAT" + PurchLine.Amount;            end else                if PurchLine."VAT Calculation Type" = PurchLine."VAT Calculation Type"::"Full VAT" then begin                    IsHandled := false;                    OnDivideAmountOnBeforeCalcAmountsForFullVAT(PurchHeader, PurchLine, IsHandled);                    if not IsHandled then                        if PurchLine."Line Discount %" <> 100 then                            PurchLine."Amount Including VAT" := PurchLine.CalcLineAmount()                        else                            PurchLine."Amount Including VAT" := 0;                    PurchLine.Amount := 0;                    PurchLine."VAT Base Amount" := 0;                end else begin                    PurchLine.Amount := PurchLine.CalcLineAmount();                    PurchLine."VAT Base Amount" :=                      Round(                        PurchLine.Amount * (1 - PurchHeader."VAT Base Discount %" / 100), Currency."Amount Rounding Precision");                    OnDivideAmountOnAfterCalcVATBaseAmount(PurchLine);                    if TempVATAmountLine."VAT Base" = 0 then                        TempVATAmountLineRemainder."VAT Amount" := 0                    else                        TempVATAmountLineRemainder."VAT Amount" +=                          TempVATAmountLine."VAT Amount" * PurchLine.CalcLineAmount() / TempVATAmountLine.CalcLineAmount();                    IsHandled := false;                    OnDivideAmountOnBeforeAmountIncludingVATAmountRound(PurchLine, TempVATAmountLineRemainder, Currency, IsHandled);                    if not IsHandled then                        if PurchLine."Line Discount %" <> 100 then                            PurchLine."Amount Including VAT" :=                                PurchLine.Amount + Round(TempVATAmountLineRemainder."VAT Amount", Currency."Amount Rounding Precision")                        else                            PurchLine."Amount Including VAT" := 0;                    TempVATAmountLineRemainder."VAT Amount" :=                      TempVATAmountLineRemainder."VAT Amount" - PurchLine."Amount Including VAT" + PurchLine.Amount;                end;            NonDeductibleVAT.DivideNonDeductibleVATInPurchaseLine(                PurchLine, TempVATAmountLineRemainder, TempVATAmountLine, Currency, PurchLine.CalcLineAmount(), TempVATAmountLine.CalcLineAmount());            OnDivideAmountOnBeforeTempVATAmountLineRemainderModify(PurchHeader, PurchLine, TempVATAmountLine, TempVATAmountLineRemainder, Currency);            TempVATAmountLineRemainder.Modify();#pragma warning disable AA0005            if PurchLine."Deferral Code" <> '' then begin                GetInvoicePostingSetup();                InvoicePostingInterface.CalcDeferralAmounts(PurchHeader, PurchLine, OriginalDeferralAmount);            end;#pragma warning restore AA0005        end;        OnAfterDivideAmount(PurchHeader, PurchLine, QtyType, PurchLineQty, TempVATAmountLine, TempVATAmountLineRemainder);    end;    local procedure CalcLineAmountAndLineDiscountAmount(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; PurchLineQty: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcLineAmountAndLineDiscountAmount(PurchHeader, PurchLine, PurchLineQty, IsHandled, Currency);        if IsHandled then            exit;        PurchLine."Line Amount" := PurchLine.GetLineAmountToHandleInclPrepmt(PurchLineQty) + GetPrepmtDiffToLineAmount(PurchLine);        if PurchLineQty <> PurchLine.Quantity then            PurchLine."Line Discount Amount" :=              Round(PurchLine."Line Discount Amount" * PurchLineQty / PurchLine.Quantity, Currency."Amount Rounding Precision");    end;    local procedure CalculateAmountsInclVAT(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalculateAmountsInclVAT(PurchHeader, PurchLine, TempVATAmountLine, TempVATAmountLineRemainder, Currency, IsHandled);        if IsHandled then            exit;        if PurchLine."Line Discount %" <> 100 then            PurchLine."Amount Including VAT" :=                Round(TempVATAmountLineRemainder."Amount Including VAT", Currency."Amount Rounding Precision")        else            PurchLine."Amount Including VAT" := 0;        PurchLine.Amount :=            Round(PurchLine."Amount Including VAT", Currency."Amount Rounding Precision") -            Round(TempVATAmountLineRemainder."VAT Amount", Currency."Amount Rounding Precision");        PurchLine."VAT Base Amount" :=            Round(                PurchLine.Amount * (1 - PurchHeader."VAT Base Discount %" / 100), Currency."Amount Rounding Precision");    end;    local procedure RoundAmount(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; PurchLineQty: Decimal)    var        NoVAT: Boolean;        IsHandled: Boolean;    begin        OnBeforeRoundAmount(PurchaseHeader, PurchaseLine, PurchLineQty);        IncrAmount(PurchaseHeader, PurchaseLine, TotalPurchLine);        TotalPurchLine."Net Weight" += Round(PurchLineQty * PurchaseLine."Net Weight", UOMMgt.WeightRndPrecision());        TotalPurchLine."Gross Weight" += Round(PurchLineQty * PurchaseLine."Gross Weight", UOMMgt.WeightRndPrecision());        TotalPurchLine."Unit Volume" += Round(PurchLineQty * PurchaseLine."Unit Volume", UOMMgt.CubageRndPrecision());        TotalPurchLine.Quantity += PurchLineQty;        if PurchaseLine."Units per Parcel" > 0 then            TotalPurchLine."Units per Parcel" += Round(PurchLineQty / PurchaseLine."Units per Parcel", 1, '>');        xPurchLine := PurchaseLine;        PurchLineACY := PurchaseLine;        IsHandled := false;        OnRoundAmountOnBeforeCalculateLCYAmounts(xPurchLine, PurchLineACY, PurchaseHeader, IsHandled, TotalPurchLine, TotalPurchLineLCY, PurchaseLine);        if not IsHandled then            if PurchaseHeader."Currency Code" <> '' then                RoundAmountInCurrency(PurchaseHeader, PurchaseLine);        IsHandled := false;        OnRoundAmountOnBeforeIncrAmount(PurchaseHeader, PurchaseLine, PurchLineQty, TotalPurchLine, TotalPurchLineLCY, xPurchLine, CurrExchRate, NoVAT, IsHandled, NonDeductibleVAT);        if not IsHandled then begin            IncrAmount(PurchaseHeader, PurchaseLine, TotalPurchLineLCY);            TotalPurchLineLCY."Unit Cost (LCY)" += Round(PurchLineQty * PurchaseLine."Unit Cost (LCY)");        end;        OnAfterRoundAmount(PurchaseHeader, PurchaseLine, PurchLineQty);    end;    local procedure RoundAmountInCurrency(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line")    var        NoVAT: Boolean;    begin        NoVAT := PurchaseLine.Amount = PurchaseLine."Amount Including VAT";        PurchaseLine."Amount Including VAT" :=            Round(                CurrExchRate.ExchangeAmtFCYToLCY(                    PurchaseHeader.GetUseDate(), PurchaseHeader."Currency Code",                    TotalPurchLine."Amount Including VAT", PurchaseHeader."Currency Factor")) -                TotalPurchLineLCY."Amount Including VAT";        if NoVAT then            PurchaseLine.Amount := PurchaseLine."Amount Including VAT"        else            PurchaseLine.Amount :=                Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                    PurchaseHeader.GetUseDate(), PurchaseHeader."Currency Code",                    TotalPurchLine.Amount, PurchaseHeader."Currency Factor")) -                TotalPurchLineLCY.Amount;        PurchaseLine."Line Amount" :=            Round(                CurrExchRate.ExchangeAmtFCYToLCY(                    PurchaseHeader.GetUseDate(), PurchaseHeader."Currency Code",                    TotalPurchLine."Line Amount", PurchaseHeader."Currency Factor")) -            TotalPurchLineLCY."Line Amount";        PurchaseLine."Line Discount Amount" :=            Round(                CurrExchRate.ExchangeAmtFCYToLCY(                    PurchaseHeader.GetUseDate(), PurchaseHeader."Currency Code",                    TotalPurchLine."Line Discount Amount", PurchaseHeader."Currency Factor")) -            TotalPurchLineLCY."Line Discount Amount";        PurchaseLine."Inv. Discount Amount" :=            Round(                CurrExchRate.ExchangeAmtFCYToLCY(                    PurchaseHeader.GetUseDate(), PurchaseHeader."Currency Code",                    TotalPurchLine."Inv. Discount Amount", PurchaseHeader."Currency Factor")) -            TotalPurchLineLCY."Inv. Discount Amount";        PurchaseLine."VAT Difference" :=            Round(                CurrExchRate.ExchangeAmtFCYToLCY(                    PurchaseHeader.GetUseDate(), PurchaseHeader."Currency Code",                    TotalPurchLine."VAT Difference", PurchaseHeader."Currency Factor")) -            TotalPurchLineLCY."VAT Difference";        if NoVAT then            PurchaseLine."VAT Base Amount" := PurchaseLine."Amount Including VAT"        else            PurchaseLine."VAT Base Amount" :=                Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                        PurchaseHeader.GetUseDate(), PurchaseHeader."Currency Code",                        TotalPurchLine."VAT Base Amount", PurchaseHeader."Currency Factor")) -                TotalPurchLineLCY."VAT Base Amount";        NonDeductibleVAT.RoundNonDeductibleVAT(PurchaseHeader, PurchaseLine, TotalPurchLine, TotalPurchLineLCY);    end;    /// <summary>    /// Reverses all quantities and amounts of the purchase line    /// If non-deductible VAT is enabled, related fields are also reversed    /// </summary>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    procedure ReverseAmount(var PurchLine: Record "Purchase Line")    begin        PurchLine."Qty. to Receive" := -PurchLine."Qty. to Receive";        PurchLine."Qty. to Receive (Base)" := -PurchLine."Qty. to Receive (Base)";        PurchLine."Return Qty. to Ship" := -PurchLine."Return Qty. to Ship";        PurchLine."Return Qty. to Ship (Base)" := -PurchLine."Return Qty. to Ship (Base)";        PurchLine."Qty. to Invoice" := -PurchLine."Qty. to Invoice";        PurchLine."Qty. to Invoice (Base)" := -PurchLine."Qty. to Invoice (Base)";        PurchLine."Line Amount" := -PurchLine."Line Amount";        PurchLine.Amount := -PurchLine.Amount;        PurchLine."VAT Base Amount" := -PurchLine."VAT Base Amount";        PurchLine."VAT Difference" := -PurchLine."VAT Difference";        PurchLine."Amount Including VAT" := -PurchLine."Amount Including VAT";        PurchLine."Line Discount Amount" := -PurchLine."Line Discount Amount";        PurchLine."Inv. Discount Amount" := -PurchLine."Inv. Discount Amount";        PurchLine."Salvage Value" := -PurchLine."Salvage Value";        NonDeductibleVAT.Reverse(PurchLine);        OnAfterReverseAmount(PurchLine);    end;    local procedure InvoiceRounding(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; UseTempData: Boolean; BiggestLineNo: Integer)    var        VendPostingGr: Record "Vendor Posting Group";        InvoiceRoundingAmount: Decimal;    begin        Currency.TestField("Invoice Rounding Precision");        InvoiceRoundingAmount :=          -Round(            TotalPurchLine."Amount Including VAT" -            Round(              TotalPurchLine."Amount Including VAT", Currency."Invoice Rounding Precision", Currency.InvoiceRoundingDirection()),            Currency."Amount Rounding Precision");        OnBeforeInvoiceRoundingAmount(          PurchHeader, TotalPurchLine."Amount Including VAT", UseTempData, InvoiceRoundingAmount, SuppressCommit, PurchLine);        if InvoiceRoundingAmount <> 0 then begin            VendPostingGr.Get(PurchHeader."Vendor Posting Group");            VendPostingGr.TestField("Invoice Rounding Account");            PurchLine.Init();            BiggestLineNo := BiggestLineNo + 10000;            PurchLine."System-Created Entry" := true;            if UseTempData then begin                PurchLine."Line No." := 0;                PurchLine.Type := PurchLine.Type::"G/L Account";            end else begin                PurchLine."Line No." := BiggestLineNo;                PurchLine.Validate(Type, PurchLine.Type::"G/L Account");            end;            PurchLine.Validate("No.", VendPostingGr.GetInvRoundingAccount());            PurchLine.Validate(Quantity, 1);            if PurchLine.IsCreditDocType() then                PurchLine.Validate("Return Qty. to Ship", PurchLine.Quantity)            else                PurchLine.Validate("Qty. to Receive", PurchLine.Quantity);            if PurchHeader."Prices Including VAT" then                PurchLine.Validate("Direct Unit Cost", InvoiceRoundingAmount)            else                PurchLine.Validate(                  "Direct Unit Cost",                  Round(                    InvoiceRoundingAmount /                    (1 + (1 - PurchHeader."VAT Base Discount %" / 100) * PurchLine."VAT %" / 100),                    Currency."Amount Rounding Precision"));            PurchLine.Validate("Amount Including VAT", InvoiceRoundingAmount);            PurchLine."Line No." := BiggestLineNo;            LastLineRetrieved := false;            RoundingLineInserted := true;            RoundingLineNo := PurchLine."Line No.";        end;        OnAfterInvoiceRoundingAmount(          PurchHeader, PurchLine, TotalPurchLine, UseTempData, InvoiceRoundingAmount, SuppressCommit, RoundingLineInserted, RoundingLineNo);    end;    /// <summary>    /// Increases all amount fields on the sum purchase line record with current line values    /// If non-deductible VAT is enabled, related fields are also increased    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    /// <param name="TotalPurchLine">Return Value: Record to store the sum of all purchase lines related to document being posted</param>    procedure IncrAmount(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; var TotalPurchLine: Record "Purchase Line")    begin        if PurchHeader."Prices Including VAT" or           (PurchLine."VAT Calculation Type" <> PurchLine."VAT Calculation Type"::"Full VAT")        then            TotalPurchLine."Line Amount" += PurchLine."Line Amount";        TotalPurchLine.Amount += PurchLine.Amount;        TotalPurchLine."VAT Base Amount" += PurchLine."VAT Base Amount";        TotalPurchLine."VAT Difference" += PurchLine."VAT Difference";        TotalPurchLine."Amount Including VAT" += PurchLine."Amount Including VAT";        TotalPurchLine."Line Discount Amount" += PurchLine."Line Discount Amount";        TotalPurchLine."Inv. Discount Amount" += PurchLine."Inv. Discount Amount";        TotalPurchLine."Inv. Disc. Amount to Invoice" += PurchLine."Inv. Disc. Amount to Invoice";        TotalPurchLine."Prepmt. Line Amount" += PurchLine."Prepmt. Line Amount";        TotalPurchLine."Prepmt. Amt. Inv." += PurchLine."Prepmt. Amt. Inv.";        TotalPurchLine."Prepmt Amt to Deduct" += PurchLine."Prepmt Amt to Deduct";        TotalPurchLine."Prepmt Amt Deducted" += PurchLine."Prepmt Amt Deducted";        TotalPurchLine."Prepayment VAT Difference" += PurchLine."Prepayment VAT Difference";        TotalPurchLine."Prepmt VAT Diff. to Deduct" += PurchLine."Prepmt VAT Diff. to Deduct";        TotalPurchLine."Prepmt VAT Diff. Deducted" += PurchLine."Prepmt VAT Diff. Deducted";        NonDeductibleVAT.Increment(TotalPurchLine, PurchLine);        OnAfterIncrAmount(TotalPurchLine, PurchLine);    end;    local procedure GetPurchaseHeader(var PurchaseHeader: Record "Purchase Header")    var        PurchaseHeaderCopy: Record "Purchase Header";    begin        PurchaseHeaderCopy := PurchaseHeader;        PurchaseHeader.ReadIsolation := IsolationLevel::ReadCommitted;        PurchaseHeader.Get(PurchaseHeader."Document Type", PurchaseHeader."No.");        PurchaseHeader := PurchaseHeaderCopy;    end;    /// <summary>    /// Collects the purchase lines for the specified Purchase Header and stores them in the PurchLine 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>    /// Temporary/buffer table TempPurchLineGlobal is populated as part of the process    /// </remarks>    /// <param name="PurchHeader">The Purchase Header of the document.</param>    /// <param name="PurchLine">Return Variable: The PurchLine 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 = Return Qty. to Ship or Qty. to Receive.</param>    procedure GetPurchLines(var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; QtyType: Option General,Invoicing,Shipping)    begin        OnBeforeGetPurchLines(PurchHeader);        FillTempLines(PurchHeader, TempPurchLineGlobal);        OnGetPurchLinesOnAfterFillTempLines(PurchHeader, PurchLine, QtyType, TempPurchLineGlobal);        if QtyType = QtyType::Invoicing then            CreatePrepmtLines(PurchHeader, false);        SumPurchLines2(PurchHeader, PurchLine, TempPurchLineGlobal, QtyType, true);    end;    /// <summary>    /// Sums the purchase lines for the specified Purchase Header and stores the results in the NewTotalPurchLine and NewTotalPurchLineLCY 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>        /// it always takes the lines for the specified Purchase Header (doesn't support a parameter for filtered or temp purchase lines).    /// </remarks>    /// <param name="NewPurchHeader">The Purchase 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 = Return Qty. to Ship or Qty. to Receive.</param>    /// <param name="NewTotalPurchLine">Return Variable: The NewTotalPurchLine record to store the summed amounts in.</param>    /// <param name="NewTotalPurchLineLCY">Return Variable: The NewTotalPurchLineLCY 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>    procedure SumPurchLines(var NewPurchHeader: Record "Purchase Header"; QtyType: Option General,Invoicing,Shipping; var NewTotalPurchLine: Record "Purchase Line"; var NewTotalPurchLineLCY: Record "Purchase Line"; var VATAmount: Decimal; var VATAmountText: Text[30])    var        OldPurchLine: Record "Purchase Line";    begin        SumPurchLinesTemp(          NewPurchHeader, OldPurchLine, QtyType, NewTotalPurchLine, NewTotalPurchLineLCY,          VATAmount, VATAmountText);    end;    /// <summary>    /// Sums the purchase lines for the specified Purchase Header (within the filters that are already set on OldPurchLine) and stores the results in the NewTotalPurchLine and NewTotalPurchLineLCY 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>    /// OldPurchLine can be a temporary variable    /// </remarks>    /// <param name="PurchHeader">The Purchase Header of the document.</param>    /// <param name="OldPurchLine">The Purchase Lines to sum.</param>    /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Return Qty. to Ship or Qty. to Receive.</param>    /// <param name="NewTotalPurchLine">Return Variable: The NewTotalPurchLine record to store the summed amounts in.</param>    /// <param name="NewTotalPurchLineLCY">Return Variable: The NewTotalPurchLineLCY 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>    procedure SumPurchLinesTemp(var PurchHeader: Record "Purchase Header"; var OldPurchLine: Record "Purchase Line"; QtyType: Option General,Invoicing,Shipping; var NewTotalPurchLine: Record "Purchase Line"; var NewTotalPurchLineLCY: Record "Purchase Line"; var VATAmount: Decimal; var VATAmountText: Text[30])    var        PurchLine: Record "Purchase Line";    begin        OnBeforeSumPurchLinesTemp(PurchHeader);        SumPurchLines2(PurchHeader, PurchLine, OldPurchLine, QtyType, false);        VATAmount := TotalPurchLine."Amount Including VAT" - TotalPurchLine.Amount;        if TotalPurchLine."VAT %" = 0 then            VATAmountText := VATAmountTxt        else            VATAmountText := StrSubstNo(VATRateTxt, TotalPurchLine.GetVATPct());        NewTotalPurchLine := TotalPurchLine;        NewTotalPurchLineLCY := TotalPurchLineLCY;    end;    /// <summary>    /// Collects the purchase lines for the specified Purchase Header and stores them in the PurchLine 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.        /// If Invoice Rounding functionality is enabled, rounding line is created    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="NewPurchLine">Record used to store new purchase lines with total quantities</param>    /// <param name="OldPurchLine">Record used to calculate VAT Amounts and process already existing lines by looping through records with filters for the document type and number applied. Information is then transferred to NewPurchLine</param>    /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Return Qty. to Ship or Qty. to Receive.</param>    /// <param name="InsertPurchLine">Determines if the new line should be inserted</param>    procedure SumPurchLines2(PurchHeader: Record "Purchase Header"; var NewPurchLine: Record "Purchase Line"; var OldPurchLine: Record "Purchase Line"; QtyType: Option General,Invoicing,Shipping; InsertPurchLine: Boolean)    var        PurchLine: Record "Purchase Line";        TempVATAmountLine: Record "VAT Amount Line" temporary;        TempVATAmountLineRemainder: Record "VAT Amount Line" temporary;        IsHandled: Boolean;        PurchLineQty: Decimal;        BiggestLineNo: Integer;    begin        IsHandled := false;        OnBeforeSumPurchLines2(QtyType, PurchHeader, OldPurchLine, TempVATAmountLine, InsertPurchLine, IsHandled);        if IsHandled then            exit;        TempVATAmountLineRemainder.DeleteAll();        OldPurchLine.CalcVATAmountLines(QtyType, PurchHeader, OldPurchLine, TempVATAmountLine);        GetGLSetup();        GetPurchSetup();        GetCurrency(PurchHeader."Currency Code");        OldPurchLine.SetRange("Document Type", PurchHeader."Document Type");        OldPurchLine.SetRange("Document No.", PurchHeader."No.");        OnSumPurchLines2OnAfterSetFilters(OldPurchLine, PurchHeader);        RoundingLineInserted := false;        if OldPurchLine.FindSet() then            repeat                if not RoundingLineInserted then                    PurchLine := OldPurchLine;                OnSumPurchLines2OnAfterIsRoundingLineInserted(PurchHeader, PurchLine, OldPurchLine, RoundingLineInserted);                case QtyType of                    QtyType::General:                        PurchLineQty := PurchLine.Quantity;                    QtyType::Invoicing:                        PurchLineQty := PurchLine."Qty. to Invoice";                    QtyType::Shipping:                        if PurchHeader.IsCreditDocType() then                            PurchLineQty := PurchLine."Return Qty. to Ship"                        else                            PurchLineQty := PurchLine."Qty. to Receive"                end;                OnSumPurchLines2OnBeforeDivideAmount(PurchHeader, PurchLine, QtyType, PurchLineQty);                DivideAmount(PurchHeader, PurchLine, QtyType, PurchLineQty, TempVATAmountLine, TempVATAmountLineRemainder);                OnSumPurchLines2OnAfterDivideAmount(PurchHeader, PurchLine, QtyType, PurchLineQty, TempVATAmountLine, TempVATAmountLineRemainder);                PurchLine.Quantity := PurchLineQty;                if PurchLineQty <> 0 then begin                    if (PurchLine.Amount <> 0) and not RoundingLineInserted then                        if TotalPurchLine.Amount = 0 then                            TotalPurchLine."VAT %" := PurchLine."VAT %"                        else                            if TotalPurchLine."VAT %" <> PurchLine."VAT %" then                                TotalPurchLine."VAT %" := 0;                    RoundAmount(PurchHeader, PurchLine, PurchLineQty);                    PurchLine := xPurchLine;                end;                if InsertPurchLine then begin                    NewPurchLine := PurchLine;                    NewPurchLine.Insert();                end;                if RoundingLineInserted then                    LastLineRetrieved := true                else begin                    BiggestLineNo := MAX(BiggestLineNo, OldPurchLine."Line No.");                    LastLineRetrieved := OldPurchLine.Next() = 0;                    if LastLineRetrieved and PurchSetup."Invoice Rounding" then                        InvoiceRounding(PurchHeader, PurchLine, true, BiggestLineNo);                end;            until LastLineRetrieved;        OnAfterSumPurchLines2(PurchHeader, OldPurchLine, NewPurchLine);    end;    /// <summary>    /// Updates the associated blanket purchase order line if it still exists.    /// </summary>    /// <remarks>    /// Blanket Purchase document must be for the same vendor as document being posted. In case of vendor mismatch an error is raised    /// Quantities on Blanket Purchase Document cannot exceed already received quantity after update. If the quantity is exceeded an error is raised    /// </remarks>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    /// <param name="Receive">When set to TRUE "Qty. to Receive" is used for blanket document update</param>    /// <param name="Ship">When set to TRUE "Return Qty. to Ship" is used for blanket document update</param>    /// <param name="Invoice">When set to TRUE "Qty. to Invoice" is used for blanket document update</param>    procedure UpdateBlanketOrderLine(PurchLine: Record "Purchase Line"; Receive: Boolean; Ship: Boolean; Invoice: Boolean)    var        BlanketOrderPurchLine: Record "Purchase Line";        ModifyLine: Boolean;        Sign: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateBlanketOrderLine(PurchLine, Receive, Ship, Invoice, IsHandled);        if IsHandled then            exit;        if (PurchLine."Blanket Order No." <> '') and (PurchLine."Blanket Order Line No." <> 0) and           ((Receive and (PurchLine."Qty. to Receive" <> 0)) or            (Ship and (PurchLine."Return Qty. to Ship" <> 0)) or            (Invoice and (PurchLine."Qty. to Invoice" <> 0)))        then            if BlanketOrderPurchLine.Get(                 BlanketOrderPurchLine."Document Type"::"Blanket Order", PurchLine."Blanket Order No.",                 PurchLine."Blanket Order Line No.")            then begin                IsHandled := false;                OnUpdateBlanketOrderLineOnBeforeCheckBlanketOrderPurchLine(BlanketOrderPurchLine, PurchLine, IsHandled);                if not IsHandled then begin                    BlanketOrderPurchLine.TestField(Type, PurchLine.Type);                    BlanketOrderPurchLine.TestField("No.", PurchLine."No.");                    BlanketOrderPurchLine.TestField("Buy-from Vendor No.", PurchLine."Buy-from Vendor No.");                end;                OnUpdateBlanketOrderLineOnAfterCheckBlanketOrderPurchLine(BlanketOrderPurchLine, PurchLine);                ModifyLine := false;                case PurchLine."Document Type" of                    PurchLine."Document Type"::Order,                  PurchLine."Document Type"::Invoice:                        Sign := 1;                    PurchLine."Document Type"::"Return Order",                  PurchLine."Document Type"::"Credit Memo":                        Sign := -1;                    else                        OnUpdateBlanketOrderLineOnTypeCaseElse(PurchLine, Sign);                end;                if Receive and not PurchLine.IsMatchedToReceiptOrOrder() then begin                    if BlanketOrderPurchLine."Qty. per Unit of Measure" =                       PurchLine."Qty. per Unit of Measure"                    then                        BlanketOrderPurchLine."Quantity Received" :=                          BlanketOrderPurchLine."Quantity Received" + Sign * PurchLine."Qty. to Receive"                    else                        BlanketOrderPurchLine."Quantity Received" :=                          BlanketOrderPurchLine."Quantity Received" +                          Sign *                          Round(                            (PurchLine."Qty. per Unit of Measure" /                             BlanketOrderPurchLine."Qty. per Unit of Measure") * PurchLine."Qty. to Receive",                            UOMMgt.QtyRndPrecision());                    BlanketOrderPurchLine."Qty. Received (Base)" :=                      BlanketOrderPurchLine."Qty. Received (Base)" + Sign * PurchLine."Qty. to Receive (Base)";                    ModifyLine := true;                end;                if Ship and (PurchLine."Return Shipment No." = '') then begin                    if BlanketOrderPurchLine."Qty. per Unit of Measure" =                       PurchLine."Qty. per Unit of Measure"                    then                        BlanketOrderPurchLine."Quantity Received" :=                          BlanketOrderPurchLine."Quantity Received" + Sign * PurchLine."Return Qty. to Ship"                    else                        BlanketOrderPurchLine."Quantity Received" :=                          BlanketOrderPurchLine."Quantity Received" +                          Sign *                          Round(                            (PurchLine."Qty. per Unit of Measure" /                             BlanketOrderPurchLine."Qty. per Unit of Measure") * PurchLine."Return Qty. to Ship",                            UOMMgt.QtyRndPrecision());                    BlanketOrderPurchLine."Qty. Received (Base)" :=                      BlanketOrderPurchLine."Qty. Received (Base)" + Sign * PurchLine."Return Qty. to Ship (Base)";                    ModifyLine := true;                end;                if Invoice then begin                    if BlanketOrderPurchLine."Qty. per Unit of Measure" =                       PurchLine."Qty. per Unit of Measure"                    then                        BlanketOrderPurchLine."Quantity Invoiced" :=                          BlanketOrderPurchLine."Quantity Invoiced" + Sign * PurchLine."Qty. to Invoice"                    else                        BlanketOrderPurchLine."Quantity Invoiced" :=                          BlanketOrderPurchLine."Quantity Invoiced" +                          Sign *                          Round(                            (PurchLine."Qty. per Unit of Measure" /                             BlanketOrderPurchLine."Qty. per Unit of Measure") * PurchLine."Qty. to Invoice",                            UOMMgt.QtyRndPrecision());                    BlanketOrderPurchLine."Qty. Invoiced (Base)" :=                      BlanketOrderPurchLine."Qty. Invoiced (Base)" + Sign * PurchLine."Qty. to Invoice (Base)";                    ModifyLine := true;                end;                if ModifyLine then begin                    OnUpdateBlanketOrderLineOnBeforeInitOutstanding(BlanketOrderPurchLine, PurchLine, Ship, Receive, Invoice);                    BlanketOrderPurchLine.InitOutstanding();                    IsHandled := false;                    OnUpdateBlanketOrderLineOnBeforeCheck(BlanketOrderPurchLine, PurchLine, IsHandled, Ship, Receive, Invoice);                    if not IsHandled then begin                        if (BlanketOrderPurchLine.Quantity * BlanketOrderPurchLine."Quantity Received" < 0) or                           (Abs(BlanketOrderPurchLine.Quantity) < Abs(BlanketOrderPurchLine."Quantity Received"))                        then                            BlanketOrderPurchLine.FieldError(                              "Quantity Received",                              StrSubstNo(BlanketOrderQuantityGreaterThanErr, BlanketOrderPurchLine.FieldCaption(Quantity)));                        if (BlanketOrderPurchLine."Quantity (Base)" * BlanketOrderPurchLine."Qty. Received (Base)" < 0) or                           (Abs(BlanketOrderPurchLine."Quantity (Base)") < Abs(BlanketOrderPurchLine."Qty. Received (Base)"))                        then                            BlanketOrderPurchLine.FieldError(                              "Qty. Received (Base)",                              StrSubstNo(BlanketOrderQuantityGreaterThanErr, BlanketOrderPurchLine.FieldCaption("Quantity Received")));                        BlanketOrderPurchLine.CalcFields("Reserved Qty. (Base)");                        if Abs(BlanketOrderPurchLine."Outstanding Qty. (Base)") < Abs(BlanketOrderPurchLine."Reserved Qty. (Base)") then                            BlanketOrderPurchLine.FieldError(                              "Reserved Qty. (Base)", BlanketOrderQuantityReducedErr);                    end;                    BlanketOrderPurchLine."Qty. to Invoice" :=                        BlanketOrderPurchLine.Quantity - BlanketOrderPurchLine."Quantity Invoiced";                    if (PurchLine.Quantity = PurchLine."Quantity Received") or (PurchLine."Quantity Received" = 0) then                        BlanketOrderPurchLine."Qty. to Receive" :=                            BlanketOrderPurchLine.Quantity - BlanketOrderPurchLine."Quantity Received";                    BlanketOrderPurchLine."Qty. to Invoice (Base)" :=                        BlanketOrderPurchLine."Quantity (Base)" - BlanketOrderPurchLine."Qty. Invoiced (Base)";                    if (PurchLine."Quantity (Base)" = PurchLine."Qty. Received (Base)") or (PurchLine."Qty. Received (Base)" = 0) then                        BlanketOrderPurchLine."Qty. to Receive (Base)" :=                            BlanketOrderPurchLine."Quantity (Base)" - BlanketOrderPurchLine."Qty. Received (Base)";                    OnBeforeBlanketOrderPurchLineModify(BlanketOrderPurchLine, PurchLine, Ship, Receive, Invoice);                    BlanketOrderPurchLine.Modify();                    OnAfterBlanketOrderPurchLineModify(BlanketOrderPurchLine, PurchLine, Ship, Receive, Invoice);                end;            end;    end;    local procedure UpdatePurchaseHeader(var VendorLedgerEntry: Record "Vendor Ledger Entry"; var PurchaseHeader: Record "Purchase Header")    var        GenJnlLine: Record "Gen. Journal Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdatePurchaseHeader(VendorLedgerEntry, PurchInvHeader, PurchCrMemoHeader, GenJnlLineDocType.AsInteger(), IsHandled, PurchaseHeader, GenJnlLineDocNo, PreviewMode);        if IsHandled then            exit;        case GenJnlLineDocType of            GenJnlLine."Document Type"::Invoice:                begin                    FindVendorLedgerEntry(GenJnlLineDocType, GenJnlLineDocNo, VendorLedgerEntry);                    PurchInvHeader."Vendor Ledger Entry No." := VendorLedgerEntry."Entry No.";                    PurchInvHeader.Modify();                end;            GenJnlLine."Document Type"::"Credit Memo":                begin                    FindVendorLedgerEntry(GenJnlLineDocType, GenJnlLineDocNo, VendorLedgerEntry);                    PurchCrMemoHeader."Vendor Ledger Entry No." := VendorLedgerEntry."Entry No.";                    PurchCrMemoHeader.Modify();                end;        end;        OnAfterUpdatePurchaseHeader(VendorLedgerEntry, PurchInvHeader, PurchCrMemoHeader, GenJnlLineDocType.AsInteger(), GenJnlLineDocNo, PreviewMode, PurchaseHeader);    end;    local procedure FindVendorLedgerEntry(DocType: Enum "Gen. Journal Document Type"; DocNo: Code[20]; var VendorLedgerEntry: Record "Vendor Ledger Entry")    begin        VendorLedgerEntry.SetRange("Document Type", DocType);        VendorLedgerEntry.SetRange("Document No.", DocNo);        VendorLedgerEntry.FindLast();    end;    local procedure CheckPostRestrictions(PurchaseHeader: Record "Purchase Header")    var        Vendor: Record Vendor;        Contact: Record Contact;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckPostRestrictions(PurchaseHeader, IsHandled);        if IsHandled then            exit;        if not PreviewMode then            PurchaseHeader.CheckPurchasePostRestrictions();        Vendor.Get(PurchaseHeader."Buy-from Vendor No.");        Vendor.CheckBlockedVendOnDocs(Vendor, true);        PurchaseHeader.ValidatePurchaserOnPurchHeader(PurchaseHeader, true, true);        if PurchaseHeader."Pay-to Vendor No." <> PurchaseHeader."Buy-from Vendor No." then begin            Vendor.Get(PurchaseHeader."Pay-to Vendor No.");            Vendor.CheckBlockedVendOnDocs(Vendor, true);        end;        if PurchaseHeader."Buy-from Contact No." <> '' then            if Contact.Get(PurchaseHeader."Buy-from Contact No.") then                Contact.CheckIfPrivacyBlocked(true);        if PurchaseHeader."Pay-to Contact No." <> '' then            if Contact.Get(PurchaseHeader."Pay-to Contact No.") then                Contact.CheckIfPrivacyBlocked(true);    end;    local procedure CheckFAPostingPossibility(PurchaseHeader: Record "Purchase Header")    var        PurchaseLine: Record "Purchase Line";        PurchaseLineToFind: Record "Purchase Line";        FADepreciationBook: Record "FA Depreciation Book";        HasBookValue: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckFAPostingPossibility(PurchaseHeader, IsHandled);        if IsHandled then            exit;        PurchaseLine.SetRange("Document Type", PurchaseHeader."Document Type");        PurchaseLine.SetRange("Document No.", PurchaseHeader."No.");        PurchaseLine.SetRange(Type, PurchaseLine.Type::"Fixed Asset");        PurchaseLine.SetFilter("No.", '<>%1', '');        if PurchaseLine.FindSet() then            repeat                PurchaseLineToFind.CopyFilters(PurchaseLine);                PurchaseLineToFind.SetRange("No.", PurchaseLine."No.");                PurchaseLineToFind.SetRange("Depr. until FA Posting Date", not PurchaseLine."Depr. until FA Posting Date");                if not PurchaseLineToFind.IsEmpty() then                    Error(ErrorInfo.Create(StrSubstNo(MixedDerpFAUntilPostingDateErr, PurchaseLine."No."), true, PurchaseLine));                if PurchaseLine."Depr. until FA Posting Date" then begin                    PurchaseLineToFind.SetRange("Depr. until FA Posting Date", true);                    PurchaseLineToFind.SetFilter("Line No.", '<>%1', PurchaseLine."Line No.");                    if not PurchaseLineToFind.IsEmpty() then begin                        HasBookValue := false;                        FADepreciationBook.SetRange("FA No.", PurchaseLine."No.");                        FADepreciationBook.FindSet();                        repeat                            FADepreciationBook.CalcFields("Book Value");                            HasBookValue := HasBookValue or (FADepreciationBook."Book Value" <> 0);                        until (FADepreciationBook.Next() = 0) or HasBookValue;                        if not HasBookValue then                            Error(ErrorInfo.Create(StrSubstNo(CannotPostSameMultipleFAWhenDeprBookValueZeroErr, PurchaseLine."No."), true, PurchaseLine));                    end;                end;            until PurchaseLine.Next() = 0;    end;    local procedure DeleteItemChargeAssgnt(PurchHeader: Record "Purchase Header")    var        ItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)";    begin        ItemChargeAssgntPurch.SetRange("Document Type", PurchHeader."Document Type");        ItemChargeAssgntPurch.SetRange("Document No.", PurchHeader."No.");        if not ItemChargeAssgntPurch.IsEmpty() then            ItemChargeAssgntPurch.DeleteAll();        OnAfterDeleteItemChargeAssgnt(PurchHeader);    end;    local procedure UpdateItemChargeAssgnt(var PurchHeader: Record "Purchase Header")    var        ItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateItemChargeAssgnt(PurchHeader, IsHandled);        if IsHandled then            exit;        ClearItemChargeAssgntFilter();        TempItemChargeAssgntPurch.MarkedOnly(true);        if TempItemChargeAssgntPurch.FindSet() then            repeat                ItemChargeAssgntPurch.Get(TempItemChargeAssgntPurch."Document Type", TempItemChargeAssgntPurch."Document No.", TempItemChargeAssgntPurch."Document Line No.", TempItemChargeAssgntPurch."Line No.");                ItemChargeAssgntPurch."Qty. Assigned" += ItemChargeAssgntPurch."Qty. to Handle";                ItemChargeAssgntPurch."Qty. to Assign" -= ItemChargeAssgntPurch."Qty. to Handle";                ItemChargeAssgntPurch."Amount to Assign" -= ItemChargeAssgntPurch."Amount to Handle";                ItemChargeAssgntPurch."Qty. to Handle" := 0;                ItemChargeAssgntPurch."Amount to Handle" := 0;                OnUpdateItemChargeAssgntOnBeforeItemChargeAssignmentPurchModify(ItemChargeAssgntPurch);                ItemChargeAssgntPurch.Modify();            until TempItemChargeAssgntPurch.Next() = 0;    end;    /// <summary>    /// Updates entries in table "Item Charge Assignment (Purch)" for document applied to purchase line being posted.    /// If purchase line is not applied, new Item Charge Assignment (Purch) entry will be created    /// </summary>    /// <remarks>    /// If document line is applied either Purchase Receipt or Return Shipment must exist    /// </remarks>    /// <param name="PurchOrderInvLine">The purchase line of the document that is being posted.</param>    /// <param name="PurchOrderLine">The purchase order (or purchase return order) line associated with the document line that is being posted.</param>    procedure UpdatePurchOrderChargeAssgnt(PurchOrderInvLine: Record "Purchase Line"; PurchOrderLine: Record "Purchase Line")    var        PurchOrderLine2: Record "Purchase Line";        PurchOrderInvLine2: Record "Purchase Line";        PurchRcptLine: Record "Purch. Rcpt. Line";        ReturnShptLine: Record "Return Shipment Line";        DocumentNo: Code[20];    begin        ClearItemChargeAssgntFilter();        TempItemChargeAssgntPurch.SetRange("Document Type", PurchOrderInvLine."Document Type");        TempItemChargeAssgntPurch.SetRange("Document No.", PurchOrderInvLine."Document No.");        TempItemChargeAssgntPurch.SetRange("Document Line No.", PurchOrderInvLine."Line No.");        TempItemChargeAssgntPurch.MarkedOnly(true);        if TempItemChargeAssgntPurch.FindSet() then            repeat                if TempItemChargeAssgntPurch."Applies-to Doc. Type" = PurchOrderInvLine."Document Type" then begin                    PurchOrderInvLine2.Get(                      TempItemChargeAssgntPurch."Applies-to Doc. Type",                      TempItemChargeAssgntPurch."Applies-to Doc. No.",                      TempItemChargeAssgntPurch."Applies-to Doc. Line No.");                    if PurchOrderLine."Document Type" = PurchOrderLine."Document Type"::Order then begin                        if not                           PurchRcptLine.Get(PurchOrderInvLine2."Receipt No.", PurchOrderInvLine2."Receipt Line No.")                        then                            Error(ReceiptLinesDeletedErr);                        PurchOrderLine2.Get(                          PurchOrderLine2."Document Type"::Order,                          PurchRcptLine."Order No.", PurchRcptLine."Order Line No.");                        DocumentNo := PurchRcptLine."Order No.";                    end else begin                        if not                           ReturnShptLine.Get(PurchOrderInvLine2."Return Shipment No.", PurchOrderInvLine2."Return Shipment Line No.")                        then                            Error(ReturnShipmentLinesDeletedErr);                        PurchOrderLine2.Get(                          PurchOrderLine2."Document Type"::"Return Order",                          ReturnShptLine."Return Order No.", ReturnShptLine."Return Order Line No.");                        DocumentNo := ReturnShptLine."Return Order No.";                    end;                    if PurchOrderLine2."Document No." = DocumentNo then                        UpdatePurchChargeAssgntLines(                          PurchOrderLine,                          PurchOrderLine2."Document Type",                          PurchOrderLine2."Document No.",                          PurchOrderLine2."Line No.",                          TempItemChargeAssgntPurch."Qty. to Handle");                end else                    UpdatePurchChargeAssgntLines(                      PurchOrderLine,                      TempItemChargeAssgntPurch."Applies-to Doc. Type",                      TempItemChargeAssgntPurch."Applies-to Doc. No.",                      TempItemChargeAssgntPurch."Applies-to Doc. Line No.",                      TempItemChargeAssgntPurch."Qty. to Handle");            until TempItemChargeAssgntPurch.Next() = 0;    end;    local procedure UpdatePurchChargeAssgntLines(PurchOrderLine: Record "Purchase Line"; ApplToDocType: Enum "Purchase Applies-to Document Type"; ApplToDocNo: Code[20]; ApplToDocLineNo: Integer; QtytoHandle: Decimal)    var        ItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)";        TempItemChargeAssgntPurch2: Record "Item Charge Assignment (Purch)";        LastLineNo: Integer;        TotalToAssign: Decimal;    begin        ItemChargeAssgntPurch.SetRange("Document Type", PurchOrderLine."Document Type");        ItemChargeAssgntPurch.SetRange("Document No.", PurchOrderLine."Document No.");        ItemChargeAssgntPurch.SetRange("Document Line No.", PurchOrderLine."Line No.");        ItemChargeAssgntPurch.SetRange("Applies-to Doc. Type", ApplToDocType);        ItemChargeAssgntPurch.SetRange("Applies-to Doc. No.", ApplToDocNo);        ItemChargeAssgntPurch.SetRange("Applies-to Doc. Line No.", ApplToDocLineNo);        if ItemChargeAssgntPurch.FindFirst() then begin            GetCurrency(PurchOrderLine."Currency Code");            ItemChargeAssgntPurch."Qty. Assigned" += QtyToHandle;            ItemChargeAssgntPurch."Qty. to Assign" -= QtyToHandle;            ItemChargeAssgntPurch."Qty. to Handle" -= QtyToHandle;            if ItemChargeAssgntPurch."Qty. to Assign" < 0 then                ItemChargeAssgntPurch."Qty. to Assign" := 0;            ItemChargeAssgntPurch."Amount to Assign" :=              Round(ItemChargeAssgntPurch."Qty. to Assign" * ItemChargeAssgntPurch."Unit Cost", Currency."Amount Rounding Precision");            if ItemChargeAssgntPurch."Qty. to Handle" < 0 then                ItemChargeAssgntPurch."Qty. to Handle" := 0;            ItemChargeAssgntPurch."Amount to Handle" :=              Round(ItemChargeAssgntPurch."Qty. to Handle" * ItemChargeAssgntPurch."Unit Cost", Currency."Amount Rounding Precision");            ItemChargeAssgntPurch.Modify();            if ItemChargeAssgntPurch."Qty. Assigned" = PurchOrderLine.Quantity then                DeleteItemChargeLines(ItemChargeAssgntPurch);        end else begin            ItemChargeAssgntPurch.SetRange("Applies-to Doc. Type");            ItemChargeAssgntPurch.SetRange("Applies-to Doc. No.");            ItemChargeAssgntPurch.SetRange("Applies-to Doc. Line No.");            ItemChargeAssgntPurch.CalcSums("Qty. to Assign", "Qty. to Handle");            TempItemChargeAssgntPurch2.SetRange("Document Type", TempItemChargeAssgntPurch."Document Type");            TempItemChargeAssgntPurch2.SetRange("Document No.", TempItemChargeAssgntPurch."Document No.");            TempItemChargeAssgntPurch2.SetRange("Document Line No.", TempItemChargeAssgntPurch."Document Line No.");            TempItemChargeAssgntPurch2.CalcSums("Qty. to Assign", "Qty. to Handle");            TotalToAssign := ItemChargeAssgntPurch."Qty. to Handle" +              TempItemChargeAssgntPurch2."Qty. to Handle";            if ItemChargeAssgntPurch.FindLast() then                LastLineNo := ItemChargeAssgntPurch."Line No.";            if PurchOrderLine.Quantity < TotalToAssign then                repeat                    TotalToAssign -= ItemChargeAssgntPurch."Qty. to Handle";                    ItemChargeAssgntPurch."Qty. to Assign" -= ItemChargeAssgntPurch."Qty. to Handle";                    ItemChargeAssgntPurch."Amount to Assign" -= ItemChargeAssgntPurch."Amount to Handle";                    ItemChargeAssgntPurch."Qty. to Handle" := 0;                    ItemChargeAssgntPurch."Amount to Handle" := 0;                    ItemChargeAssgntPurch.Modify();                until (ItemChargeAssgntPurch.Next(-1) = 0) or                      (TotalToAssign = PurchOrderLine.Quantity);            InsertAssocOrderCharge(              PurchOrderLine, ApplToDocType, ApplToDocNo, ApplToDocLineNo, LastLineNo,              TempItemChargeAssgntPurch."Applies-to Doc. Line Amount");        end;    end;    local procedure InsertAssocOrderCharge(PurchOrderLine: Record "Purchase Line"; ApplToDocType: Enum "Purchase Applies-to Document Type"; ApplToDocNo: Code[20]; ApplToDocLineNo: Integer; LastLineNo: Integer; ApplToDocLineAmt: Decimal)    var        NewItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)";    begin        NewItemChargeAssgntPurch.Init();        NewItemChargeAssgntPurch."Document Type" := PurchOrderLine."Document Type";        NewItemChargeAssgntPurch."Document No." := PurchOrderLine."Document No.";        NewItemChargeAssgntPurch."Document Line No." := PurchOrderLine."Line No.";        NewItemChargeAssgntPurch."Line No." := LastLineNo + 10000;        NewItemChargeAssgntPurch."Item Charge No." := TempItemChargeAssgntPurch."Item Charge No.";        NewItemChargeAssgntPurch."Item No." := TempItemChargeAssgntPurch."Item No.";        NewItemChargeAssgntPurch."Qty. Assigned" := TempItemChargeAssgntPurch."Qty. to Handle";        NewItemChargeAssgntPurch."Qty. to Handle" := 0;        NewItemChargeAssgntPurch."Amount to Handle" := 0;        NewItemChargeAssgntPurch.Description := TempItemChargeAssgntPurch.Description;        NewItemChargeAssgntPurch."Unit Cost" := TempItemChargeAssgntPurch."Unit Cost";        NewItemChargeAssgntPurch."Applies-to Doc. Type" := ApplToDocType;        NewItemChargeAssgntPurch."Applies-to Doc. No." := ApplToDocNo;        NewItemChargeAssgntPurch."Applies-to Doc. Line No." := ApplToDocLineNo;        NewItemChargeAssgntPurch."Applies-to Doc. Line Amount" := ApplToDocLineAmt;        OnInsertAssocOrderChargeOnBeforeInsert(TempItemChargeAssgntPurch, NewItemChargeAssgntPurch);        NewItemChargeAssgntPurch.Insert();    end;    /// <summary>    /// Populates global temporary table TempItemChargeAssgntPurch and checks if charge quantity does not exceed quantity to invoice    /// If document is being invoiced in full (no remaining quantity) and not all charges have been assigned, an error is raised    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    procedure CopyAndCheckItemCharge(PurchHeader: Record "Purchase Header")    var        TempPurchLine: Record "Purchase Line" temporary;        InvoiceEverything: Boolean;        AssignError: Boolean;    begin        TempItemChargeAssgntPurch.Reset();        TempItemChargeAssgntPurch.DeleteAll();        // Check for max qty posting        ResetTempLines(TempPurchLine);        TempPurchLine.SetRange(Type, TempPurchLine.Type::"Charge (Item)");        OnCopyAndCheckItemChargeOnBeforeCheckIfEmpty(TempPurchLine);        if TempPurchLine.IsEmpty() then            exit;        CopyItemChargeForPurchLine(TempItemChargeAssgntPurch, TempPurchLine);        TempPurchLine.SetFilter("Qty. to Invoice", '<>0');        if TempPurchLine.FindSet() then            repeat                OnCopyAndCheckItemChargeOnBeforeLoop(TempPurchLine, PurchHeader);                CopyAndCheckItemChargeTempPurchLine(PurchHeader, TempPurchLine, AssignError);            until TempPurchLine.Next() = 0;        // Check purchlines        if AssignError then            if PurchHeader."Document Type" in               [PurchHeader."Document Type"::Invoice, PurchHeader."Document Type"::"Credit Memo"]            then                InvoiceEverything := true            else begin                TempPurchLine.Reset();                TempPurchLine.SetFilter(Type, '%1|%2', TempPurchLine.Type::Item, TempPurchLine.Type::"Charge (Item)");                CalculateInvoiceEverything(TempPurchLine, PurchHeader, InvoiceEverything);            end;        if InvoiceEverything and AssignError then            Error(ErrorInfo.Create(MustAssignErr, true, PurchHeader));    end;    local procedure CalculateInvoiceEverything(var TempPurchaseLine: Record "Purchase Line" temporary; PurchaseHeader: Record "Purchase Header"; var InvoiceEverything: Boolean)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalculateInvoiceEverything(TempPurchaseLine, PurchaseHeader, InvoiceEverything, IsHandled);        if IsHandled then            exit;        if TempPurchaseLine.FindSet() then            repeat                if PurchaseHeader.Ship or PurchaseHeader.Receive then                    InvoiceEverything := TempPurchaseLine.Quantity = TempPurchaseLine."Qty. to Invoice" + TempPurchaseLine."Quantity Invoiced"                else                    InvoiceEverything := (TempPurchaseLine.Quantity = TempPurchaseLine."Qty. to Invoice" + TempPurchaseLine."Quantity Invoiced") and                      (TempPurchaseLine."Qty. to Invoice" = TempPurchaseLine."Qty. Rcd. Not Invoiced" + TempPurchaseLine."Return Qty. Shipped Not Invd.");            until (TempPurchaseLine.Next() = 0) or (not InvoiceEverything);    end;    local procedure CopyAndCheckItemChargeTempPurchLine(PurchHeader: Record "Purchase Header"; TempPurchLine: Record "Purchase Line" temporary; var AssignError: Boolean)    var        PurchLine: Record "Purchase Line";        QtyNeeded: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCopyAndCheckItemChargeTempPurchLine(PurchHeader, TempPurchLine, TempItemChargeAssgntPurch, IsHandled, AssignError);        if IsHandled then            exit;        TempPurchLine.TestField("Job No.", '');        if PurchHeader.Invoice and           (TempPurchLine."Qty. to Receive" + TempPurchLine."Return Qty. to Ship" <> 0) and           ((PurchHeader.Ship or PurchHeader.Receive) or            (Abs(TempPurchLine."Qty. to Invoice") >             Abs(TempPurchLine."Qty. Rcd. Not Invoiced" + TempPurchLine."Qty. to Receive") +             Abs(TempPurchLine."Ret. Qty. Shpd Not Invd.(Base)" + TempPurchLine."Return Qty. to Ship")))        then            TempPurchLine.TestField("Line Amount");        if not PurchHeader.Receive then            TempPurchLine."Qty. to Receive" := 0;        if not PurchHeader.Ship then            TempPurchLine."Return Qty. to Ship" := 0;        if Abs(TempPurchLine."Qty. to Invoice") >           Abs(TempPurchLine."Quantity Received" + TempPurchLine."Qty. to Receive" +             TempPurchLine."Return Qty. Shipped" + TempPurchLine."Return Qty. to Ship" -             TempPurchLine."Quantity Invoiced")        then            TempPurchLine."Qty. to Invoice" :=              TempPurchLine."Quantity Received" + TempPurchLine."Qty. to Receive" +              TempPurchLine."Return Qty. Shipped (Base)" + TempPurchLine."Return Qty. to Ship (Base)" -              TempPurchLine."Quantity Invoiced";        TempPurchLine.CalcFields("Qty. to Assign", "Qty. Assigned", "Item Charge Qty. to Handle");        if Abs(TempPurchLine."Item Charge Qty. to Handle" + TempPurchLine."Qty. Assigned") >           Abs(TempPurchLine."Qty. to Invoice" + TempPurchLine."Quantity Invoiced")        then begin            AdjustQtyToAssignForPurchLine(TempPurchLine);            TempPurchLine.CalcFields("Qty. to Assign", "Qty. Assigned", "Item Charge Qty. to Handle");            if Abs(TempPurchLine."Item Charge Qty. to Handle" + TempPurchLine."Qty. Assigned") >               Abs(TempPurchLine."Qty. to Invoice" + TempPurchLine."Quantity Invoiced")            then                Error(CannotAssignMoreErr,                  TempPurchLine."Qty. to Invoice" + TempPurchLine."Quantity Invoiced" - TempPurchLine."Qty. Assigned",                  TempPurchLine.FieldCaption("Document Type"), TempPurchLine."Document Type",                  TempPurchLine.FieldCaption("Document No."), TempPurchLine."Document No.",                  TempPurchLine.FieldCaption("Line No."), TempPurchLine."Line No.");            CopyItemChargeForPurchLine(TempItemChargeAssgntPurch, TempPurchLine);        end;        if TempPurchLine.Quantity = TempPurchLine."Qty. to Invoice" + TempPurchLine."Quantity Invoiced" then begin            if TempPurchLine."Item Charge Qty. to Handle" <> 0 then                if TempPurchLine.Quantity = TempPurchLine."Quantity Invoiced" then begin                    TempItemChargeAssgntPurch.SetRange("Document Line No.", TempPurchLine."Line No.");                    TempItemChargeAssgntPurch.SetRange("Applies-to Doc. Type", TempPurchLine."Document Type");                    if TempItemChargeAssgntPurch.FindSet() then                        repeat                            PurchLine.Get(                              TempItemChargeAssgntPurch."Applies-to Doc. Type",                              TempItemChargeAssgntPurch."Applies-to Doc. No.",                              TempItemChargeAssgntPurch."Applies-to Doc. Line No.");                            if PurchLine.Quantity = PurchLine."Quantity Invoiced" then                                Error(CannotAssignInvoicedErr, PurchLine.TableCaption(),                                  PurchLine.FieldCaption("Document Type"), PurchLine."Document Type",                                  PurchLine.FieldCaption("Document No."), PurchLine."Document No.",                                  PurchLine.FieldCaption("Line No."), PurchLine."Line No.");                        until TempItemChargeAssgntPurch.Next() = 0;                end;            if TempPurchLine.Quantity <> TempPurchLine."Item Charge Qty. to Handle" + TempPurchLine."Qty. Assigned" then                AssignError := true;        end;        if (TempPurchLine."Item Charge Qty. to Handle" + TempPurchLine."Qty. Assigned") < (TempPurchLine."Qty. to Invoice" + TempPurchLine."Quantity Invoiced") then            Error(MustAssignItemChargeErr, TempPurchLine."No.");        // check if all ILEs exist        QtyNeeded := TempPurchLine."Item Charge Qty. to Handle";        TempItemChargeAssgntPurch.SetRange("Document Line No.", TempPurchLine."Line No.");        if TempItemChargeAssgntPurch.FindSet() then            repeat                if (TempItemChargeAssgntPurch."Applies-to Doc. Type" <> TempPurchLine."Document Type") or                   (TempItemChargeAssgntPurch."Applies-to Doc. No." <> TempPurchLine."Document No.")                then                    QtyNeeded := QtyNeeded - TempItemChargeAssgntPurch."Qty. to Handle"                else begin                    PurchLine.Get(                      TempItemChargeAssgntPurch."Applies-to Doc. Type",                      TempItemChargeAssgntPurch."Applies-to Doc. No.",                      TempItemChargeAssgntPurch."Applies-to Doc. Line No.");                    if ItemLedgerEntryExist(PurchLine, PurchHeader.Receive or PurchHeader.Ship) then                        QtyNeeded := QtyNeeded - TempItemChargeAssgntPurch."Qty. to Handle";                end;            until TempItemChargeAssgntPurch.Next() = 0;        if QtyNeeded <> 0 then            Error(CannotInvoiceItemChargeErr, TempPurchLine."No.");    end;    local procedure CopyItemChargeForPurchLine(var TempItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)" temporary; PurchaseLine: Record "Purchase Line")    var        ItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)";    begin        TempItemChargeAssignmentPurch.Reset();        TempItemChargeAssignmentPurch.SetRange("Document Type", PurchaseLine."Document Type");        TempItemChargeAssignmentPurch.SetRange("Document No.", PurchaseLine."Document No.");        if not TempItemChargeAssignmentPurch.IsEmpty() then            TempItemChargeAssignmentPurch.DeleteAll();        ItemChargeAssgntPurch.Reset();        ItemChargeAssgntPurch.SetRange("Document Type", PurchaseLine."Document Type");        ItemChargeAssgntPurch.SetRange("Document No.", PurchaseLine."Document No.");        ItemChargeAssgntPurch.SetFilter("Qty. to Assign", '<>0');        if ItemChargeAssgntPurch.FindSet() then            repeat                TempItemChargeAssignmentPurch.Init();                TempItemChargeAssignmentPurch := ItemChargeAssgntPurch;                TempItemChargeAssignmentPurch.Insert();            until ItemChargeAssgntPurch.Next() = 0;    end;    local procedure AdjustQtyToAssignForPurchLine(var TempPurchaseLine: Record "Purchase Line" temporary)    var        ItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)";    begin        TempPurchaseLine.CalcFields("Qty. to Assign");        ItemChargeAssgntPurch.Reset();        ItemChargeAssgntPurch.SetRange("Document Type", TempPurchaseLine."Document Type");        ItemChargeAssgntPurch.SetRange("Document No.", TempPurchaseLine."Document No.");        ItemChargeAssgntPurch.SetRange("Document Line No.", TempPurchaseLine."Line No.");        ItemChargeAssgntPurch.SetFilter("Qty. to Assign", '<>0');        if ItemChargeAssgntPurch.FindSet() then            repeat                ItemChargeAssgntPurch.Validate("Qty. to Assign",                  TempPurchaseLine."Qty. to Invoice" * Round(ItemChargeAssgntPurch."Qty. to Assign" / TempPurchaseLine."Qty. to Assign",                    UOMMgt.QtyRndPrecision()));                ItemChargeAssgntPurch.Modify();            until ItemChargeAssgntPurch.Next() = 0;        TempPurchaseLine.CalcFields("Qty. to Assign");        if TempPurchaseLine."Qty. to Assign" < TempPurchaseLine."Qty. to Invoice" then begin            ItemChargeAssgntPurch.Validate("Qty. to Assign",              ItemChargeAssgntPurch."Qty. to Assign" + Abs(TempPurchaseLine."Qty. to Invoice" - TempPurchaseLine."Qty. to Assign"));            ItemChargeAssgntPurch.Modify();        end;        if TempPurchaseLine."Qty. to Assign" > TempPurchaseLine."Qty. to Invoice" then begin            ItemChargeAssgntPurch.Validate("Qty. to Assign",              ItemChargeAssgntPurch."Qty. to Assign" - Abs(TempPurchaseLine."Qty. to Invoice" - TempPurchaseLine."Qty. to Assign"));            ItemChargeAssgntPurch.Modify();        end;    end;    local procedure ClearItemChargeAssgntFilter()    begin        TempItemChargeAssgntPurch.SetRange("Document Line No.");        TempItemChargeAssgntPurch.SetRange("Applies-to Doc. Type");        TempItemChargeAssgntPurch.SetRange("Applies-to Doc. No.");        TempItemChargeAssgntPurch.SetRange("Applies-to Doc. Line No.");        TempItemChargeAssgntPurch.MarkedOnly(false);    end;    local procedure GetItemChargeLine(PurchHeader: Record "Purchase Header"; var ItemChargePurchLine: Record "Purchase Line")    var        QtyReceived: Decimal;        QtyReturnShipped: Decimal;    begin        if (ItemChargePurchLine."Document Type" <> TempItemChargeAssgntPurch."Document Type") or            (ItemChargePurchLine."Document No." <> TempItemChargeAssgntPurch."Document No.") or            (ItemChargePurchLine."Line No." <> TempItemChargeAssgntPurch."Document Line No.")        then begin            ItemChargePurchLine.Get(TempItemChargeAssgntPurch."Document Type", TempItemChargeAssgntPurch."Document No.", TempItemChargeAssgntPurch."Document Line No.");            OnGetItemChargeLineOnAfterGet(ItemChargePurchLine, PurchHeader);            if not PurchHeader.Receive then                ItemChargePurchLine."Qty. to Receive" := 0;            if not PurchHeader.Ship then                ItemChargePurchLine."Return Qty. to Ship" := 0;            if ItemChargePurchLine."Receipt No." = '' then                QtyReceived := ItemChargePurchLine."Quantity Received"            else                QtyReceived := TempItemChargeAssgntPurch."Qty. to Handle";            if ItemChargePurchLine."Return Shipment No." = '' then                QtyReturnShipped := ItemChargePurchLine."Return Qty. Shipped"            else                QtyReturnShipped := TempItemChargeAssgntPurch."Qty. to Handle";            if Abs(ItemChargePurchLine."Qty. to Invoice") >               Abs(QtyReceived + ItemChargePurchLine."Qty. to Receive" +                 QtyReturnShipped + ItemChargePurchLine."Return Qty. to Ship" -                 ItemChargePurchLine."Quantity Invoiced")            then                ItemChargePurchLine."Qty. to Invoice" :=                  QtyReceived + ItemChargePurchLine."Qty. to Receive" +                  QtyReturnShipped + ItemChargePurchLine."Return Qty. to Ship" -                  ItemChargePurchLine."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 GetGLSetup()    begin        if not GLSetupRead then            GLSetup.Get();        GLSetupRead := true;    end;    local procedure GetPurchSetup()    begin        if not PurchSetupRead then            PurchSetup.Get();        PurchSetupRead := true;        OnAfterGetPurchSetup(PurchSetup);    end;    local procedure GetInvoicePostingSetup()    var        IsHandled: Boolean;    begin        if IsInterfaceInitialized then            exit;        IsHandled := false;        OnBeforeGetInvoicePostingSetup(InvoicePostingInterface, IsHandled);        if not IsHandled then            InvoicePostingInterface := Enum::"Purchase Invoice Posting"::"Invoice Posting (v.19)";        InvoicePostingInterface.Check(Database::"Purchase Header");        IsInterfaceInitialized := true;        InvoicePostingInterface.SetHideProgressWindow(HideProgressWindow);        InvoicePostingInterface.SetPreviewMode(PreviewMode);        InvoicePostingInterface.SetSuppressCommit(SuppressCommit);    end;    local procedure GetInvoicePostingParameters()    begin        Clear(InvoicePostingParameters);        InvoicePostingParameters."Document Type" := GenJnlLineDocType;        InvoicePostingParameters."Document No." := GenJnlLineDocNo;        InvoicePostingParameters."External Document No." := GenJnlLineExtDocNo;        InvoicePostingParameters."Source Code" := SrcCode;        InvoicePostingParameters."Auto Document No." := '';    end;    local procedure CheckWarehouse(var TempItemPurchLine: Record "Purchase Line" temporary)    var        WhseValidateSourceLine: Codeunit "Whse. Validate Source Line";        ShowError: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckWarehouse(TempItemPurchLine, IsHandled);        if IsHandled then            exit;        if TempItemPurchLine.IsProdOrder() then            exit;        TempItemPurchLine.SetRange(Type, TempItemPurchLine.Type::Item);        TempItemPurchLine.SetRange("Drop Shipment", false);        OnCheckWarehouseOnAfterSetFilters(TempItemPurchLine);        if TempItemPurchLine.FindSet() then            repeat                if TempItemPurchLine.IsInventoriableItem() then begin                    GetLocation(TempItemPurchLine."Location Code");                    case TempItemPurchLine."Document Type" of                        TempItemPurchLine."Document Type"::Order:                            if ((Location."Require Receive" or Location."Require Put-away") and (TempItemPurchLine.Quantity >= 0)) or                               ((Location."Require Shipment" or Location."Require Pick") and (TempItemPurchLine.Quantity < 0))                            then                                if Location."Directed Put-away and Pick" then                                    ShowError := true                                else                                    if WhseValidateSourceLine.WhseLinesExist(                                         DATABASE::"Purchase Line", TempItemPurchLine."Document Type".AsInteger(), TempItemPurchLine."Document No.", TempItemPurchLine."Line No.", 0, TempItemPurchLine.Quantity)                                    then                                        ShowError := true;                        TempItemPurchLine."Document Type"::"Return Order":                            if ((Location."Require Receive" or Location."Require Put-away") and (TempItemPurchLine.Quantity < 0)) or                               ((Location."Require Shipment" or Location."Require Pick") and (TempItemPurchLine.Quantity >= 0))                            then                                if Location."Directed Put-away and Pick" then                                    ShowError := true                                else                                    if WhseValidateSourceLine.WhseLinesExist(                                         DATABASE::"Purchase Line", TempItemPurchLine."Document Type".AsInteger(), TempItemPurchLine."Document No.", TempItemPurchLine."Line No.", 0, TempItemPurchLine.Quantity)                                    then                                        ShowError := true;                        TempItemPurchLine."Document Type"::Invoice, TempItemPurchLine."Document Type"::"Credit Memo":                            if Location."Directed Put-away and Pick" then                                Location.TestField("Adjustment Bin Code");                    end;                    if ShowError then                        Error(                          WarehouseRequiredErr,                          TempItemPurchLine.FieldCaption("Document Type"), TempItemPurchLine."Document Type",                          TempItemPurchLine.FieldCaption("Document No."), TempItemPurchLine."Document No.",                          TempItemPurchLine.FieldCaption("Line No."), TempItemPurchLine."Line No.");                end;            until TempItemPurchLine.Next() = 0;    end;    local procedure CreateWhseJnlLine(ItemJnlLine: Record "Item Journal Line"; PurchLine: Record "Purchase Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary)    var        WhseMgt: Codeunit "Whse. Management";        WMSMgt: Codeunit "WMS Management";    begin        WMSMgt.CheckAdjmtBin(Location, ItemJnlLine.Quantity, true);        WMSMgt.CreateWhseJnlLine(ItemJnlLine, 0, TempWhseJnlLine, false);        TempWhseJnlLine.CheckBin(true);        TempWhseJnlLine."Source Type" := DATABASE::"Purchase Line";        TempWhseJnlLine."Source Subtype" := PurchLine."Document Type".AsInteger();        TempWhseJnlLine."Source Document" := WhseMgt.GetWhseJnlSourceDocument(TempWhseJnlLine."Source Type", TempWhseJnlLine."Source Subtype");        TempWhseJnlLine."Source No." := PurchLine."Document No.";        TempWhseJnlLine."Source Line No." := PurchLine."Line No.";        TempWhseJnlLine."Source Code" := SrcCode;        case PurchLine."Document Type" of            PurchLine."Document Type"::Order:                TempWhseJnlLine."Reference Document" :=                  TempWhseJnlLine."Reference Document"::"Posted Rcpt.";            PurchLine."Document Type"::Invoice:                TempWhseJnlLine."Reference Document" :=                  TempWhseJnlLine."Reference Document"::"Posted P. Inv.";            PurchLine."Document Type"::"Credit Memo":                TempWhseJnlLine."Reference Document" :=                  TempWhseJnlLine."Reference Document"::"Posted P. Cr. Memo";            PurchLine."Document Type"::"Return Order":                TempWhseJnlLine."Reference Document" :=                  TempWhseJnlLine."Reference Document"::"Posted Rtrn. Shipment";        end;        TempWhseJnlLine."Reference No." := ItemJnlLine."Document No.";        OnAfterCreateWhseJnlLine(PurchLine, TempWhseJnlLine);    end;    /// <summary>    /// Checks if the line requires warehouse handling    /// </summary>    /// <remarks>    /// Check is only performed if line has type Item of type Inventory and document is not drop shipment    /// If location is not set on the purchase line warehouse setup is used    /// </remarks>    /// <param name="PurchaseLine">The purchase line of the document that is being posted.</param>    /// <returns>Returns boolean if location on the line requires Pick/Receive</returns>    procedure WhseHandlingRequiredExternal(PurchaseLine: Record "Purchase Line"): Boolean    begin        exit(WhseHandlingRequired(PurchaseLine));    end;    local procedure WhseHandlingRequired(PurchLine: Record "Purchase Line") Required: Boolean    var        WhseSetup: Record "Warehouse Setup";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeWhseHandlingRequired(PurchLine, Required, IsHandled);        if IsHandled then            exit(Required);        if PurchLine.IsInventoriableItem() and (not PurchLine."Drop Shipment") then begin            if PurchLine."Location Code" = '' then begin                WhseSetup.Get();                if PurchLine."Document Type" = PurchLine."Document Type"::"Return Order" then                    exit(WhseSetup."Require Pick");                exit(WhseSetup."Require Receive");            end;            GetLocation(PurchLine."Location Code");            if PurchLine."Document Type" = PurchLine."Document Type"::"Return Order" then                exit(Location."Require Pick");            exit(Location."Require Receive");        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 InsertRcptEntryRelation(var PurchRcptLine: Record "Purch. Rcpt. Line") Result: Integer    var        ItemEntryRelation: Record "Item Entry Relation";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertRcptEntryRelation(xPurchLine, PurchRcptLine, TempHandlingSpecification, TempTrackingSpecificationInv, ItemLedgShptEntryNo, Result, IsHandled);        if IsHandled then            exit(Result);        TempHandlingSpecification.CopySpecification(TempTrackingSpecificationInv);        TempHandlingSpecification.Reset();        if TempHandlingSpecification.FindSet() then begin            repeat                ItemEntryRelation.InitFromTrackingSpec(TempHandlingSpecification);                ItemEntryRelation.TransferFieldsPurchRcptLine(PurchRcptLine);                ItemEntryRelation.Insert();            until TempHandlingSpecification.Next() = 0;            TempHandlingSpecification.DeleteAll();            exit(0);        end;        exit(ItemLedgShptEntryNo);    end;    local procedure InsertReturnEntryRelation(var ReturnShptLine: Record "Return Shipment Line"): Integer    var        ItemEntryRelation: Record "Item Entry Relation";        Result: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertReturnEntryRelation(ReturnShptLine, Result, IsHandled);        if IsHandled then            exit(Result);        TempHandlingSpecification.CopySpecification(TempTrackingSpecificationInv);        TempHandlingSpecification.Reset();        if TempHandlingSpecification.FindSet() then begin            repeat                ItemEntryRelation.Init();                ItemEntryRelation.InitFromTrackingSpec(TempHandlingSpecification);                ItemEntryRelation.TransferFieldsReturnShptLine(ReturnShptLine);                ItemEntryRelation.Insert();            until TempHandlingSpecification.Next() = 0;            TempHandlingSpecification.DeleteAll();            exit(0);        end;        exit(ItemLedgShptEntryNo);    end;    local procedure CheckTrackingSpecification(PurchHeader: Record "Purchase Header"; var TempItemPurchLine: Record "Purchase Line" temporary)    var        ReservationEntry: Record "Reservation Entry";        Item: Record Item;        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[250];        SignFactor: Integer;        PurchLineQtyToHandle: Decimal;        TrackingQtyToHandle: Decimal;        Inbound: Boolean;        CheckPurchLine: Boolean;        IsHandled: Boolean;    begin        // if a PurchaseLine is posted with ItemTracking then tracked quantity must be equal to posted quantity        if not (PurchHeader."Document Type" in                [PurchHeader."Document Type"::Order, PurchHeader."Document Type"::"Return Order"])        then            exit;        OnBeforeCheckTrackingSpecification(PurchHeader, TempItemPurchLine);        TrackingQtyToHandle := 0;        TempItemPurchLine.SetRange(Type, TempItemPurchLine.Type::Item);        if PurchHeader.Receive then begin            TempItemPurchLine.SetFilter("Quantity Received", '<>%1', 0);            ErrorFieldCaption := TempItemPurchLine.FieldCaption("Qty. to Receive");        end else begin            TempItemPurchLine.SetFilter("Return Qty. Shipped", '<>%1', 0);            ErrorFieldCaption := TempItemPurchLine.FieldCaption("Return Qty. to Ship");        end;        if TempItemPurchLine.FindSet() then begin            ReservationEntry."Source Type" := DATABASE::"Purchase Line";            ReservationEntry."Source Subtype" := PurchHeader."Document Type".AsInteger();            SignFactor := CreateReservEntry.SignFactor(ReservationEntry);            repeat                // Only Item where no SerialNo or LotNo is required                Item.Get(TempItemPurchLine."No.");                if Item."Item Tracking Code" <> '' then begin                    Inbound := (TempItemPurchLine.Quantity * SignFactor) > 0;                    ItemTrackingCode.Code := Item."Item Tracking Code";                    IsHandled := false;                    OnCheckTrackingSpecificationOnBeforeGetItemTrackingSetup(TempItemPurchLine, ItemTrackingSetup, IsHandled);                    if not IsHandled then                        ItemTrackingManagement.GetItemTrackingSetup(                           ItemTrackingCode, ItemJnlLine."Entry Type"::Purchase, Inbound, ItemTrackingSetup);                    CheckPurchLine := not ItemTrackingSetup.TrackingRequired();                    if CheckPurchLine then                        CheckPurchLine := CheckTrackingExists(TempItemPurchLine);                end else                    CheckPurchLine := false;                TrackingQtyToHandle := 0;                if CheckPurchLine then begin                    TrackingQtyToHandle := GetTrackingQuantities(TempItemPurchLine) * SignFactor;                    if PurchHeader.Receive then                        PurchLineQtyToHandle := TempItemPurchLine."Qty. to Receive (Base)"                    else                        PurchLineQtyToHandle := TempItemPurchLine."Return Qty. to Ship (Base)";                    if TrackingQtyToHandle <> PurchLineQtyToHandle then                        Error(ItemTrackQuantityMismatchErr, ErrorFieldCaption, TempItemPurchLine."No.");                end;            until TempItemPurchLine.Next() = 0;        end;        if PurchHeader.Receive then            TempItemPurchLine.SetRange("Quantity Received")        else            TempItemPurchLine.SetRange("Return Qty. Shipped");        OnAfterCheckTrackingSpecification(PurchHeader, TempItemPurchLine)    end;    local procedure CheckTrackingExists(PurchLine: Record "Purchase Line"): Boolean    begin        exit(          ItemTrackingMgt.ItemTrackingExistsOnDocumentLine(            DATABASE::"Purchase Line", PurchLine."Document Type".AsInteger(), PurchLine."Document No.", PurchLine."Line No."));    end;    /// <summary>    /// Calculates Quantity to handle in base unit of measure from the reservation entries associated with purchase line    /// </summary>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    /// <returns>Quantity to handle in base unit of measure</returns>    procedure GetTrackingQuantities(PurchLine: Record "Purchase Line"): Decimal    begin        exit(          ItemTrackingMgt.CalcQtyToHandleForTrackedQtyOnDocumentLine(            DATABASE::"Purchase Line", PurchLine."Document Type".AsInteger(), PurchLine."Document No.", PurchLine."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";                    OnSaveInvoiceSpecificationOnBeforeTempTrackingSpecificationModify(TempTrackingSpecification, TempInvoicingSpecification);                    TempTrackingSpecification.Modify();                end;                OnSaveInvoiceSpecificationOnAfterUpdateTempTrackingSpecification(TempTrackingSpecification, TempInvoicingSpecification);            until TempInvoicingSpecification.Next() = 0;            TempInvoicingSpecification.DeleteAll();        end;    end;    local procedure InsertTrackingSpecification(PurchHeader: Record "Purchase Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertTrackingSpecification(PurchHeader, TempTrackingSpecification, IsHandled);        if IsHandled then            exit;        TempTrackingSpecification.Reset();        if not TempTrackingSpecification.IsEmpty() then begin            TempTrackingSpecification.InsertSpecification();            PurchLineReserve.UpdateItemTrackingAfterPosting(PurchHeader);        end;    end;    local 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>    /// Creates and posts item journal line. Information from table "Item Charge Assignment (Purch)" is used as a base when creating journal line.    /// </summary>    /// <remarks>    /// If document being processes is either return order or credit memo, reverse amount is posted (reverse of the amount passed as parameter AmountToAssign)    /// Journal line will be posted with same dimensions purchase line of the document that is being posted.    /// Non-Deductible VAT will be updated    /// </remarks>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    /// <param name="ItemEntryNo">Entry No. (from the document or ledger) to which charges should be applied after posting</param>    /// <param name="QuantityBase">Quantity (in base unit of measure). This value is used in calculating "Unit Cost"</param>    /// <param name="AmountToAssign">Amount to be assigned. This value is used as "Amount" when posting</param>    /// <param name="QtyToAssign">Quantity to to be assigned. This will is used in calculating line amount ant discounts.</param>    /// <param name="IndirectCostPct">Indirect Cost percentage that will be assigned to purchase line field "Indirect Cost %" </param>    procedure PostItemCharge(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; ItemEntryNo: Integer; QuantityBase: Decimal; AmountToAssign: Decimal; QtyToAssign: Decimal; IndirectCostPct: Decimal)    var        DummyTrackingSpecification: Record "Tracking Specification";        PurchLineToPost: Record "Purchase Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemCharge(PurchHeader, PurchLine, ItemEntryNo, QuantityBase, AmountToAssign, QtyToAssign, IndirectCostPct, IsHandled);        if not IsHandled then begin            PurchLineToPost := PurchLine;            PurchLineToPost."No." := TempItemChargeAssgntPurch."Item No.";            PurchLineToPost."Line No." := TempItemChargeAssgntPurch."Document Line No.";            PurchLineToPost."Appl.-to Item Entry" := ItemEntryNo;            PurchLineToPost."Indirect Cost %" := IndirectCostPct;            PurchLineToPost.Amount := AmountToAssign;            if TempItemChargeAssgntPurch."Document Type" in [TempItemChargeAssgntPurch."Document Type"::"Return Order", TempItemChargeAssgntPurch."Document Type"::"Credit Memo"] then                PurchLineToPost.Amount := -PurchLineToPost.Amount;            if PurchLineToPost."Currency Code" <> '' then                PurchLineToPost."Unit Cost" := Round(                    PurchLineToPost.Amount / QuantityBase, Currency."Unit-Amount Rounding Precision")            else                PurchLineToPost."Unit Cost" := Round(                    PurchLineToPost.Amount / QuantityBase, GLSetup."Unit-Amount Rounding Precision");            TotalChargeAmt := TotalChargeAmt + PurchLineToPost.Amount;            OnPostItemChargeOnAfterCalcTotalChargeAmt(PurchLineToPost, QtyToAssign, PurchLine, xPurchLine);            if PurchHeader."Currency Code" <> '' then                PurchLineToPost.Amount :=                  CurrExchRate.ExchangeAmtFCYToLCY(                    PurchHeader.GetUseDate(), PurchHeader."Currency Code", TotalChargeAmt, PurchHeader."Currency Factor");            PurchLineToPost.Amount := Round(PurchLineToPost.Amount, GLSetup."Amount Rounding Precision") - TotalChargeAmtLCY;            if PurchHeader."Currency Code" <> '' then                TotalChargeAmtLCY := TotalChargeAmtLCY + PurchLineToPost.Amount;            PurchLineToPost."Unit Cost (LCY)" :=              Round(                PurchLineToPost.Amount / QuantityBase, GLSetup."Unit-Amount Rounding Precision");            PurchLineToPost."Inv. Discount Amount" := Round(                PurchLine."Inv. Discount Amount" / PurchLine.Quantity * QtyToAssign,                GLSetup."Amount Rounding Precision");            PurchLineToPost."Line Discount Amount" := Round(                PurchLine."Line Discount Amount" / PurchLine.Quantity * QtyToAssign,                GLSetup."Amount Rounding Precision");            PurchLineToPost."Line Amount" := Round(                PurchLine."Line Amount" / PurchLine.Quantity * QtyToAssign,                GLSetup."Amount Rounding Precision");            UpdatePurchLineDimSetIDFromAppliedEntry(PurchLineToPost, PurchLine);            PurchLine."Inv. Discount Amount" := PurchLine."Inv. Discount Amount" - PurchLineToPost."Inv. Discount Amount";            PurchLine."Line Discount Amount" := PurchLine."Line Discount Amount" - PurchLineToPost."Line Discount Amount";            PurchLine."Line Amount" := PurchLine."Line Amount" - PurchLineToPost."Line Amount";            NonDeductibleVAT.Update(PurchLineToPost, QtyToAssign, QuantityBase, GLSetup."Amount Rounding Precision");            PurchLine.Quantity := PurchLine.Quantity - QtyToAssign;            OnPostItemChargeOnBeforePostItemJnlLine(PurchLineToPost, PurchLine, QtyToAssign, TempItemChargeAssgntPurch, PurchInvHeader);            PostItemJnlLine(              PurchHeader, PurchLineToPost, 0, 0, QuantityBase, QuantityBase,              PurchLineToPost."Appl.-to Item Entry", TempItemChargeAssgntPurch."Item Charge No.", DummyTrackingSpecification);        end;        OnPostItemChargeOnAfterPostItemJnlLine(PurchHeader, PurchLineToPost, TempItemChargeAssgntPurch);    end;    procedure SaveTempWhseSplitSpec(PurchLine3: Record "Purchase Line")    begin        TempWhseSplitSpecification.Reset();        TempWhseSplitSpecification.DeleteAll();        if TempHandlingSpecification.FindSet() then            repeat                TempWhseSplitSpecification := TempHandlingSpecification;                TempWhseSplitSpecification."Source Type" := DATABASE::"Purchase Line";                TempWhseSplitSpecification."Source Subtype" := PurchLine3."Document Type".AsInteger();                TempWhseSplitSpecification."Source ID" := PurchLine3."Document No.";                TempWhseSplitSpecification."Source Ref. No." := PurchLine3."Line No.";                TempWhseSplitSpecification.Insert();            until TempHandlingSpecification.Next() = 0;        OnAfterSaveTempWhseSplitSpec(PurchLine3, TempWhseSplitSpecification);    end;    local procedure TransferReservToItemJnlLine(var SalesOrderLine: Record "Sales Line"; var ItemJnlLine: Record "Item Journal Line"; PurchLine: Record "Purchase Line"; QtyToBeShippedBase: Decimal; ApplySpecificItemTracking: Boolean)    var        SalesLineReserve: Codeunit "Sales Line-Reserve";        RemainingQuantity: Decimal;        CheckApplFromItemEntry: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTransferReservToItemJnlLine(SalesOrderLine, ItemJnlLine, PurchLine, QtyToBeShippedBase, ApplySpecificItemTracking, IsHandled);        if IsHandled then            exit;        // Handle Item Tracking and reservations, also on drop shipment        if QtyToBeShippedBase = 0 then            exit;        if not ApplySpecificItemTracking then            SalesLineReserve.TransferSalesLineToItemJnlLine(              SalesOrderLine, ItemJnlLine, QtyToBeShippedBase, CheckApplFromItemEntry, false)        else begin            SalesLineReserve.SetApplySpecificItemTracking(true);            TempTrackingSpecification.Reset();            TempTrackingSpecification.SetSourceFilter(              DATABASE::"Purchase Line", PurchLine."Document Type".AsInteger(), PurchLine."Document No.", PurchLine."Line No.", false);            TempTrackingSpecification.SetSourceFilter('', 0);            if TempTrackingSpecification.IsEmpty() then                SalesLineReserve.TransferSalesLineToItemJnlLine(                  SalesOrderLine, ItemJnlLine, QtyToBeShippedBase, CheckApplFromItemEntry, false)            else begin                SalesLineReserve.SetOverruleItemTracking(true);                TempTrackingSpecification.FindSet();                if TempTrackingSpecification."Quantity (Base)" / QtyToBeShippedBase < 0 then                    Error(ItemTrackingWrongSignErr);                repeat                    ItemJnlLine.CopyTrackingFromSpec(TempTrackingSpecification);                    ItemJnlLine."Applies-to Entry" := TempTrackingSpecification."Item Ledger Entry No.";                    RemainingQuantity :=                      SalesLineReserve.TransferSalesLineToItemJnlLine(                        SalesOrderLine, ItemJnlLine, TempTrackingSpecification."Quantity (Base)", CheckApplFromItemEntry, false);                    if RemainingQuantity <> 0 then                        Error(ItemTrackingMismatchErr);                until TempTrackingSpecification.Next() = 0;                ItemJnlLine.ClearTracking();                ItemJnlLine."Applies-to Entry" := 0;            end;        end;    end;    /// <summary>    /// Sets global variables WhseRcptHeader and TempWhseRcptHeader    /// </summary>    /// <remarks>    /// Document referenced by variable WhseRcptHeader will be updated during posting    /// Document referenced by variable TempWhseRcptHeader will be used as a basis for creating posted receipt    /// </remarks>    /// <param name="WhseRcptHeader2">Warehouse Receipt Header to be updated when posting</param>    procedure SetWhseRcptHeader(var WhseRcptHeader2: Record "Warehouse Receipt Header")    begin        WhseRcptHeader := WhseRcptHeader2;        TempWhseRcptHeader := WhseRcptHeader;        TempWhseRcptHeader.Insert();    end;    /// <summary>    /// Sets global variables WhseShptHeader and TempWhseShptHeader    /// </summary>    /// <remarks>    /// Document referenced by variable WhseShptHeader will be updated during posting    /// Document referenced by variable TempWhseShptHeader will be used as a basis for creating posted shipment    /// </remarks>    /// <param name="WhseShptHeader2">Warehouse Shipment Header to be updated when posting</param>    procedure SetWhseShptHeader(var WhseShptHeader2: Record "Warehouse Shipment Header")    begin        WhseShptHeader := WhseShptHeader2;        TempWhseShptHeader := WhseShptHeader;        TempWhseShptHeader.Insert();    end;    local procedure CreatePrepmtLines(PurchHeader: Record "Purchase Header"; CompleteFunctionality: Boolean)    var        GLAcc: Record "G/L Account";        PurchRcptLine: Record "Purch. Rcpt. Line";        TempPurchLine: Record "Purchase Line" temporary;        TempExtTextLine: Record "Extended Text Line" temporary;        GenPostingSetup: Record "General Posting Setup";        TempPrepmtPurchLine: Record "Purchase Line" temporary;        TransferExtText: Codeunit "Transfer Extended Text";        NextLineNo: Integer;        Fraction: Decimal;        VATDifference: Decimal;        TempLineFound: Boolean;        PrepmtAmtToDeduct: Decimal;        IsHandled: Boolean;        ShouldCalcAmounts: Boolean;        ShouldTestGetReceiptPPmtAmtToDeduct: Boolean;    begin        IsHandled := false;        OnBeforeCreatePrepmtLines(PurchHeader, TempPrepmtPurchLine, CompleteFunctionality, IsHandled, TempPurchLineGlobal);        if IsHandled then            exit;        GetGLSetup();        FillTempLines(PurchHeader, TempPurchLineGlobal);        ResetTempLines(TempPurchLine);        if not TempPurchLine.FindLast() then            exit;        NextLineNo := TempPurchLine."Line No." + 10000;        TempPurchLine.SetFilter(Quantity, '>0');        TempPurchLine.SetFilter("Qty. to Invoice", '>0');        OnCreatePrepmtLinesOnAfterTempPurchLineSetFilters(TempPurchLine);        if TempPurchLine.FindSet() then begin            ShouldTestGetReceiptPPmtAmtToDeduct := CompleteFunctionality and (TempPurchLine."Document Type" = TempPurchLine."Document Type"::Invoice);            OnCreatePrepaymentLinesOnBeforeShouldTestGetReceiptPPmtAmtToDeduct(PurchHeader, CompleteFunctionality, ShouldTestGetReceiptPPmtAmtToDeduct);            if ShouldTestGetReceiptPPmtAmtToDeduct then                TestGetRcptPPmtAmtToDeduct();            repeat                if CompleteFunctionality then begin                    ShouldCalcAmounts := PurchHeader."Document Type" <> PurchHeader."Document Type"::Invoice;                    OnCreatePrepmtLinesOnAfterShouldCalcAmounts(PurchHeader, ShouldCalcAmounts, TempPurchLine);                    if ShouldCalcAmounts then begin                        if not PurchHeader.Receive and (TempPurchLine."Qty. to Invoice" = TempPurchLine.Quantity - TempPurchLine."Quantity Invoiced") then                            if TempPurchLine."Qty. Rcd. Not Invoiced" < TempPurchLine."Qty. to Invoice" then                                TempPurchLine.Validate("Qty. to Invoice", TempPurchLine."Qty. Rcd. Not Invoiced");                        Fraction := (TempPurchLine."Qty. to Invoice" + TempPurchLine."Quantity Invoiced") / TempPurchLine.Quantity;                        CheckPrepmtAmtToDeduct(PurchHeader, TempPurchLine, Fraction);                    end;                end;                if TempPurchLine."Prepmt Amt to Deduct" <> 0 then begin                    if (TempPurchLine."Gen. Bus. Posting Group" <> GenPostingSetup."Gen. Bus. Posting Group") or                       (TempPurchLine."Gen. Prod. Posting Group" <> GenPostingSetup."Gen. Prod. Posting Group")                    then                        GetGeneralPostingSetup(GenPostingSetup, TempPurchLine);                    IsHandled := false;                    OnCreatePrepaymentLinesOnBeforeGetPurchPrepmtAccount(GLAcc, TempPurchLine, PurchHeader, GenPostingSetup, CompleteFunctionality, IsHandled);                    if not IsHandled then                        GLAcc.Get(GenPostingSetup.GetPurchPrepmtAccount());                    OnCreatePrepaymentLinesOnAfterGetPurchPrepmtAccount(GLAcc, TempPurchLine, PurchHeader, CompleteFunctionality);                    TempLineFound := false;                    if PurchHeader."Compress Prepayment" then begin                        TempPrepmtPurchLine.SetRange("No.", GLAcc."No.");                        TempPrepmtPurchLine.SetRange("Job No.", TempPurchLine."Job No.");                        TempPrepmtPurchLine.SetRange("Dimension Set ID", TempPurchLine."Dimension Set ID");                        OnCreatePrepmtLinesOnAfterTempPrepmtPurchLineSetFilters(TempPrepmtPurchLine, TempPurchLine);                        TempLineFound := TempPrepmtPurchLine.FindFirst();                    end;                    if TempLineFound then begin                        PrepmtAmtToDeduct :=                          TempPrepmtPurchLine."Prepmt Amt to Deduct" +                          InsertedPrepmtVATBaseToDeduct(                            PurchHeader, TempPurchLine, TempPrepmtPurchLine."Line No.", TempPrepmtPurchLine."Direct Unit Cost");                        VATDifference := TempPrepmtPurchLine."VAT Difference";                        TempPrepmtPurchLine.Validate(                          "Direct Unit Cost", TempPrepmtPurchLine."Direct Unit Cost" + TempPurchLine."Prepmt Amt to Deduct");                        TempPrepmtPurchLine.Validate("VAT Difference", VATDifference - TempPurchLine."Prepmt VAT Diff. to Deduct");                        TempPrepmtPurchLine."Prepmt Amt to Deduct" := PrepmtAmtToDeduct;                        if TempPurchLine."Prepayment %" < TempPrepmtPurchLine."Prepayment %" then                            TempPrepmtPurchLine."Prepayment %" := TempPurchLine."Prepayment %";                        OnBeforeTempPrepmtPurchLineModify(TempPrepmtPurchLine, TempPurchLine, PurchHeader, CompleteFunctionality);                        TempPrepmtPurchLine.Modify();                    end else begin                        TempPrepmtPurchLine.Init();                        TempPrepmtPurchLine."Document Type" := PurchHeader."Document Type";                        TempPrepmtPurchLine."Document No." := PurchHeader."No.";                        TempPrepmtPurchLine."Line No." := 0;                        TempPrepmtPurchLine."System-Created Entry" := true;                        OnCreatePrepmtLinesOnAfterInitTempPrepmtPurchLineFromPurchHeader(TempPrepmtPurchLine);                        if CompleteFunctionality then                            TempPrepmtPurchLine.Validate(Type, TempPrepmtPurchLine.Type::"G/L Account")                        else                            TempPrepmtPurchLine.Type := TempPrepmtPurchLine.Type::"G/L Account";                        TempPrepmtPurchLine.Validate("No.", GLAcc."No.");                        TempPrepmtPurchLine.Validate(Quantity, -1);                        TempPrepmtPurchLine."Qty. to Receive" := TempPrepmtPurchLine.Quantity;                        TempPrepmtPurchLine."Qty. to Invoice" := TempPrepmtPurchLine.Quantity;                        OnCreatePrepaymentLinesOnBeforeInsertedPrepmtVATBaseToDeduct(TempPrepmtPurchLine, PurchHeader, TempPurchLine);                        PrepmtAmtToDeduct := InsertedPrepmtVATBaseToDeduct(PurchHeader, TempPurchLine, NextLineNo, 0);                        TempPrepmtPurchLine.Validate("Direct Unit Cost", TempPurchLine."Prepmt Amt to Deduct");                        TempPrepmtPurchLine.Validate("VAT Difference", -TempPurchLine."Prepmt VAT Diff. to Deduct");                        TempPrepmtPurchLine."Prepmt Amt to Deduct" := PrepmtAmtToDeduct;                        TempPrepmtPurchLine."Prepayment %" := TempPurchLine."Prepayment %";                        TempPrepmtPurchLine."Prepayment Line" := true;                        TempPrepmtPurchLine."Shortcut Dimension 1 Code" := TempPurchLine."Shortcut Dimension 1 Code";                        TempPrepmtPurchLine."Shortcut Dimension 2 Code" := TempPurchLine."Shortcut Dimension 2 Code";                        TempPrepmtPurchLine."Dimension Set ID" := TempPurchLine."Dimension Set ID";                        TempPrepmtPurchLine."Job No." := TempPurchLine."Job No.";                        TempPrepmtPurchLine."Job Task No." := TempPurchLine."Job Task No.";                        TempPrepmtPurchLine."Job Line Type" := TempPurchLine."Job Line Type";                        if PurchRcptLine.Get(TempPurchLine."Receipt No.", TempPurchLine."Receipt Line No.") then begin                            TempPrepmtPurchLine."Order No." := PurchRcptLine."Order No.";                            TempPrepmtPurchLine."Order Line No." := PurchRcptLine."Order Line No.";                        end;                        TempPrepmtPurchLine."Line No." := NextLineNo;                        NextLineNo := NextLineNo + 10000;                        OnBeforeTempPrepmtPurchLineInsert(TempPrepmtPurchLine, TempPurchLine, PurchHeader, CompleteFunctionality);                        TempPrepmtPurchLine.Insert();                        TransferExtText.PrepmtGetAnyExtText(                          TempPrepmtPurchLine."No.", DATABASE::"Purch. Inv. Line",                          PurchHeader."Document Date", PurchHeader."Language Code", TempExtTextLine);                        if TempExtTextLine.Find('-') then                            repeat                                TempPrepmtPurchLine.Init();                                TempPrepmtPurchLine.Description := TempExtTextLine.Text;                                TempPrepmtPurchLine."System-Created Entry" := true;                                TempPrepmtPurchLine."Prepayment Line" := true;                                TempPrepmtPurchLine."Line No." := NextLineNo;                                NextLineNo := NextLineNo + 10000;                                TempPrepmtPurchLine.Insert();                            until TempExtTextLine.Next() = 0;                    end;                end;            until TempPurchLine.Next() = 0        end;        DividePrepmtAmountLCY(TempPrepmtPurchLine, PurchHeader);        if TempPrepmtPurchLine.FindSet() then            repeat                TempPurchLineGlobal := TempPrepmtPurchLine;                TempPurchLineGlobal.Insert();            until TempPrepmtPurchLine.Next() = 0;    end;    local procedure CheckPrepmtAmtToDeduct(PurchaseHeader: Record "Purchase Header"; var TempPurchaseLine: Record "Purchase Line" temporary; Fraction: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckPrepmtAmtToDeduct(PurchaseHeader, TempPurchaseLine, IsHandled);        if IsHandled then            exit;        if TempPurchaseLine."Prepayment %" <> 100 then            case true of                (TempPurchaseLine."Prepmt Amt to Deduct" <> 0) and              (Round(Fraction * TempPurchaseLine."Line Amount", Currency."Amount Rounding Precision") < TempPurchaseLine."Prepmt Amt to Deduct"):                    TempPurchaseLine.FieldError(                      "Prepmt Amt to Deduct",                      StrSubstNo(                        CannotBeGreaterThanErr,                        Round(Fraction * TempPurchaseLine."Line Amount", Currency."Amount Rounding Precision")));                (TempPurchaseLine."Prepmt. Amt. Inv." <> 0) and              (Round((1 - Fraction) * TempPurchaseLine."Line Amount", Currency."Amount Rounding Precision") <               Round(                 Round(                   Round(TempPurchaseLine."Direct Unit Cost" * (TempPurchaseLine.Quantity - TempPurchaseLine."Quantity Invoiced" - TempPurchaseLine."Qty. to Invoice"),                     Currency."Amount Rounding Precision") *                   (1 - TempPurchaseLine."Line Discount %" / 100), Currency."Amount Rounding Precision") *                 TempPurchaseLine."Prepayment %" / 100, Currency."Amount Rounding Precision")):                    TempPurchaseLine.FieldError(                      "Prepmt Amt to Deduct",                      StrSubstNo(                        CannotBeSmallerThanErr,                        Round(                          TempPurchaseLine."Prepmt. Amt. Inv." - TempPurchaseLine."Prepmt Amt Deducted" -                          (1 - Fraction) * TempPurchaseLine."Line Amount", Currency."Amount Rounding Precision")));            end;    end;    local procedure InsertedPrepmtVATBaseToDeduct(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; PrepmtLineNo: Integer; TotalPrepmtAmtToDeduct: Decimal): Decimal    var        PrepmtVATBaseToDeduct: Decimal;        IsHandled: Boolean;    begin        if PurchHeader."Prices Including VAT" then            PrepmtVATBaseToDeduct :=              Round(                (TotalPrepmtAmtToDeduct + PurchLine."Prepmt Amt to Deduct") / (1 + PurchLine."Prepayment VAT %" / 100),                Currency."Amount Rounding Precision") -              Round(                TotalPrepmtAmtToDeduct / (1 + PurchLine.GetPrepaymentVATPct() / 100),                Currency."Amount Rounding Precision")        else            PrepmtVATBaseToDeduct := PurchLine."Prepmt Amt to Deduct";        TempPrepmtDeductLCYPurchLine := PurchLine;        IsHandled := false;        OnInsertedPrepmtVATBaseToDeductOnAfterSetTempPrepmtDeductLCYPurchaseLine(TempPrepmtDeductLCYPurchLine, PrepmtVATBaseToDeduct, IsHandled);        if IsHandled then            exit(PrepmtVATBaseToDeduct);        if TempPrepmtDeductLCYPurchLine."Document Type" = TempPrepmtDeductLCYPurchLine."Document Type"::Order then            TempPrepmtDeductLCYPurchLine."Qty. to Invoice" := GetQtyToInvoice(PurchLine, PurchHeader.Receive)        else            GetLineDataFromOrder(TempPrepmtDeductLCYPurchLine);        if (TempPrepmtDeductLCYPurchLine."Prepmt Amt to Deduct" = 0) or (TempPrepmtDeductLCYPurchLine."Document Type" = TempPrepmtDeductLCYPurchLine."Document Type"::Invoice) then            TempPrepmtDeductLCYPurchLine.CalcPrepaymentToDeduct();        TempPrepmtDeductLCYPurchLine."Line Amount" := TempPrepmtDeductLCYPurchLine.GetLineAmountToHandleInclPrepmt(TempPrepmtDeductLCYPurchLine."Qty. to Invoice");        TempPrepmtDeductLCYPurchLine."Attached to Line No." := PrepmtLineNo;        TempPrepmtDeductLCYPurchLine."VAT Base Amount" := PrepmtVATBaseToDeduct;        TempPrepmtDeductLCYPurchLine.Insert();        OnAfterInsertedPrepmtVATBaseToDeduct(          PurchHeader, PurchLine, PrepmtLineNo, TotalPrepmtAmtToDeduct, TempPrepmtDeductLCYPurchLine, PrepmtVATBaseToDeduct);        exit(PrepmtVATBaseToDeduct);    end;    local procedure DividePrepmtAmountLCY(var PrepmtPurchLine: Record "Purchase Line"; PurchHeader: Record "Purchase Header")    var        ActualCurrencyFactor: Decimal;    begin        PrepmtPurchLine.Reset();        PrepmtPurchLine.SetFilter(Type, '<>%1', PrepmtPurchLine.Type::" ");        if PrepmtPurchLine.FindSet() then            repeat                if PurchHeader."Currency Code" <> '' then                    ActualCurrencyFactor :=                      Round(                        CurrExchRate.ExchangeAmtFCYToLCY(                          PurchHeader."Posting Date",                          PurchHeader."Currency Code",                          PrepmtPurchLine."Prepmt Amt to Deduct",                          PurchHeader."Currency Factor")) /                      PrepmtPurchLine."Prepmt Amt to Deduct"                else                    ActualCurrencyFactor := 1;                UpdatePrepmtAmountInvBuf(PrepmtPurchLine."Line No.", ActualCurrencyFactor);            until PrepmtPurchLine.Next() = 0;        PrepmtPurchLine.Reset();    end;    local procedure UpdatePrepmtAmountInvBuf(PrepmtSalesLineNo: Integer; CurrencyFactor: Decimal)    var        PrepmtAmtRemainder: Decimal;    begin        TempPrepmtDeductLCYPurchLine.Reset();        TempPrepmtDeductLCYPurchLine.SetRange("Attached to Line No.", PrepmtSalesLineNo);        if TempPrepmtDeductLCYPurchLine.FindSet(true) then            repeat                TempPrepmtDeductLCYPurchLine."Prepmt. Amount Inv. (LCY)" :=                  CalcRoundedAmount(CurrencyFactor * TempPrepmtDeductLCYPurchLine."VAT Base Amount", PrepmtAmtRemainder);                TempPrepmtDeductLCYPurchLine.Modify();            until TempPrepmtDeductLCYPurchLine.Next() = 0;    end;    local procedure AdjustPrepmtAmountLCY(PurchHeader: Record "Purchase Header"; var PrepmtPurchLine: Record "Purchase Line")    var        PurchLine: Record "Purchase Line";        PurchInvoiceLine: Record "Purchase Line";        TempPurchaseLineReceiptBuffer: Record "Purchase 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(PurchHeader, PrepmtPurchLine, IsHandled);        if IsHandled then            exit;        if PrepmtPurchLine."Prepayment Line" then begin            PrepmtVATPart :=              (PrepmtPurchLine."Amount Including VAT" - PrepmtPurchLine.Amount) / PrepmtPurchLine."Direct Unit Cost";            TempPrepmtDeductLCYPurchLine.Reset();            TempPrepmtDeductLCYPurchLine.SetRange("Attached to Line No.", PrepmtPurchLine."Line No.");            if TempPrepmtDeductLCYPurchLine.FindSet(true) then begin                FinalInvoice := true;                repeat                    PurchLine := TempPrepmtDeductLCYPurchLine;                    PurchLine.Find();                    if TempPrepmtDeductLCYPurchLine."Document Type" = TempPrepmtDeductLCYPurchLine."Document Type"::Invoice then begin                        PurchInvoiceLine := PurchLine;                        GetPurchOrderLine(PurchLine, PurchInvoiceLine);                        PurchLine."Qty. to Invoice" := PurchInvoiceLine."Qty. to Invoice";                        TempPurchaseLineReceiptBuffer := PurchLine;                        if TempPurchaseLineReceiptBuffer.Find() then begin                            TempPurchaseLineReceiptBuffer."Qty. to Invoice" += TempPrepmtDeductLCYPurchLine."Qty. to Invoice";                            TempPurchaseLineReceiptBuffer.Modify();                        end else begin                            TempPurchaseLineReceiptBuffer.Quantity := TempPrepmtDeductLCYPurchLine.Quantity;                            TempPurchaseLineReceiptBuffer."Qty. to Invoice" := TempPrepmtDeductLCYPurchLine."Qty. to Invoice";                            TempPurchaseLineReceiptBuffer.Insert();                        end;                        CurrentLineFinalInvoice := TempPurchaseLineReceiptBuffer.IsFinalInvoice();                    end else begin                        CurrentLineFinalInvoice := TempPrepmtDeductLCYPurchLine.IsFinalInvoice();                        FinalInvoice := FinalInvoice and CurrentLineFinalInvoice;                    end;                    if PurchLine."Qty. to Invoice" <> TempPrepmtDeductLCYPurchLine."Qty. to Invoice" then                        PurchLine."Prepmt Amt to Deduct" := CalcPrepmtAmtToDeduct(PurchLine, PurchHeader.Receive);                    DeductionFactor :=                      PurchLine."Prepmt Amt to Deduct" /                      (PurchLine."Prepmt. Amt. Inv." - PurchLine."Prepmt Amt Deducted");                    TempPrepmtDeductLCYPurchLine."Prepmt. VAT Amount Inv. (LCY)" :=                      -CalcRoundedAmount(PurchLine."Prepmt Amt to Deduct" * PrepmtVATPart, PrepmtVATAmtRemainder);                    if (TempPrepmtDeductLCYPurchLine."Prepayment %" <> 100) or CurrentLineFinalInvoice or (TempPrepmtDeductLCYPurchLine."Currency Code" <> '') then                        CalcPrepmtRoundingAmounts(TempPrepmtDeductLCYPurchLine, PurchLine, DeductionFactor, TotalRoundingAmount);                    TempPrepmtDeductLCYPurchLine.Modify();                    if PurchHeader."Prices Including VAT" then                        if ((TempPrepmtDeductLCYPurchLine."Prepayment %" <> 100) or CurrentLineFinalInvoice) and (DeductionFactor = 1) then begin                            PricesInclVATRoundingAmount[1] := TotalRoundingAmount[1];                            PricesInclVATRoundingAmount[2] := TotalRoundingAmount[2];                        end;                    if TempPrepmtDeductLCYPurchLine."VAT Calculation Type" <> TempPrepmtDeductLCYPurchLine."VAT Calculation Type"::"Full VAT" then                        TotalPrepmtAmount[1] += TempPrepmtDeductLCYPurchLine."Prepmt. Amount Inv. (LCY)";                    TotalPrepmtAmount[2] += TempPrepmtDeductLCYPurchLine."Prepmt. VAT Amount Inv. (LCY)";                until TempPrepmtDeductLCYPurchLine.Next() = 0;            end;            if FinalInvoice then                if TempPurchaseLineReceiptBuffer.FindSet() then                    repeat                        if not TempPurchaseLineReceiptBuffer.IsFinalInvoice() then                            FinalInvoice := false;                    until not FinalInvoice or (TempPurchaseLineReceiptBuffer.Next() = 0);            if PurchHeader."Document Type" <> PurchHeader."Document Type"::"Credit Memo" then                UpdatePrepmtPurchLineWithRounding(                  PrepmtPurchLine, TotalRoundingAmount, TotalPrepmtAmount,                  FinalInvoice, PricesInclVATRoundingAmount);        end;    end;    local procedure CalcPrepmtAmtToDeduct(PurchLine: Record "Purchase Line"; Receive: Boolean): Decimal    begin        PurchLine."Qty. to Invoice" := GetQtyToInvoice(PurchLine, Receive);        PurchLine.CalcPrepaymentToDeduct();        exit(PurchLine."Prepmt Amt to Deduct");    end;    local procedure GetQtyToInvoice(PurchLine: Record "Purchase Line"; Receive: Boolean): Decimal    var        AllowedQtyToInvoice: Decimal;    begin        AllowedQtyToInvoice := PurchLine."Qty. Rcd. Not Invoiced";        if Receive then            AllowedQtyToInvoice := AllowedQtyToInvoice + PurchLine."Qty. to Receive";        if PurchLine."Qty. to Invoice" > AllowedQtyToInvoice then            exit(AllowedQtyToInvoice);        exit(PurchLine."Qty. to Invoice");    end;    local procedure GetLineDataFromOrder(var PurchLine: Record "Purchase Line")    var        PurchRcptLine: Record "Purch. Rcpt. Line";        PurchOrderLine: Record "Purchase Line";    begin        PurchRcptLine.Get(PurchLine."Receipt No.", PurchLine."Receipt Line No.");        PurchOrderLine.Get(PurchLine."Document Type"::Order, PurchRcptLine."Order No.", PurchRcptLine."Order Line No.");        PurchLine.Quantity := PurchOrderLine.Quantity;        PurchLine."Qty. Rcd. Not Invoiced" := PurchOrderLine."Qty. Rcd. Not Invoiced";        PurchLine."Quantity Invoiced" := PurchOrderLine."Quantity Invoiced";        PurchLine."Prepmt Amt Deducted" := PurchOrderLine."Prepmt Amt Deducted";        PurchLine."Prepmt. Amt. Inv." := PurchOrderLine."Prepmt. Amt. Inv.";        PurchLine."Line Discount Amount" := PurchOrderLine."Line Discount Amount";        OnAfterGetLineDataFromOrder(PurchLine, PurchOrderLine);    end;    local procedure CalcPrepmtRoundingAmounts(var PrepmtPurchLineBuf: Record "Purchase Line"; PurchLine: Record "Purchase Line"; DeductionFactor: Decimal; var TotalRoundingAmount: array[2] of Decimal)    var        RoundingAmount: array[2] of Decimal;    begin        if PrepmtPurchLineBuf."VAT Calculation Type" <> PrepmtPurchLineBuf."VAT Calculation Type"::"Full VAT" then begin            RoundingAmount[1] :=              PrepmtPurchLineBuf."Prepmt. Amount Inv. (LCY)" - Round(DeductionFactor * PurchLine."Prepmt. Amount Inv. (LCY)");            PrepmtPurchLineBuf."Prepmt. Amount Inv. (LCY)" := PrepmtPurchLineBuf."Prepmt. Amount Inv. (LCY)" - RoundingAmount[1];            TotalRoundingAmount[1] += RoundingAmount[1];        end;        RoundingAmount[2] :=          PrepmtPurchLineBuf."Prepmt. VAT Amount Inv. (LCY)" - Round(DeductionFactor * PurchLine."Prepmt. VAT Amount Inv. (LCY)");        PrepmtPurchLineBuf."Prepmt. VAT Amount Inv. (LCY)" := PrepmtPurchLineBuf."Prepmt. VAT Amount Inv. (LCY)" - RoundingAmount[2];        TotalRoundingAmount[2] += RoundingAmount[2];    end;    local procedure UpdatePrepmtPurchLineWithRounding(var PrepmtPurchLine: Record "Purchase 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        OnBeforeUpdatePrepmtPurchLineWithRounding(          PrepmtPurchLine, TotalRoundingAmount, TotalPrepmtAmount, FinalInvoice, PricesInclVATRoundingAmount,          TotalPurchLine, TotalPurchLineLCY);        NewAmountIncludingVAT := TotalPrepmtAmount[1] + TotalPrepmtAmount[2] + TotalRoundingAmount[1] + TotalRoundingAmount[2];        if PrepmtPurchLine."Prepayment %" = 100 then            TotalRoundingAmount[1] -= PrepmtPurchLine."Amount Including VAT" + NewAmountIncludingVAT;        AmountRoundingPrecision :=          GetAmountRoundingPrecisionInLCY(PrepmtPurchLine."Document Type", PrepmtPurchLine."Document No.", PrepmtPurchLine."Currency Code");        if (Abs(TotalRoundingAmount[1]) <= AmountRoundingPrecision) and           (Abs(TotalRoundingAmount[2]) <= AmountRoundingPrecision) and           (PrepmtPurchLine."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 (PrepmtPurchLine."Prepayment %" <> 100)        then begin            PricesInclVATRoundingAmount[1] := 0;            TotalRoundingAmount[1] := 0;        end;        PrepmtPurchLine."Prepmt. Amount Inv. (LCY)" := -TotalRoundingAmount[1];        PrepmtPurchLine.Amount := -(TotalPrepmtAmount[1] + TotalRoundingAmount[1]);        if (PricesInclVATRoundingAmount[1] <> 0) and (TotalRoundingAmount[1] = 0) then begin            if (PrepmtPurchLine."Prepayment %" = 100) and FinalInvoice and               (PrepmtPurchLine.Amount - TotalPrepmtAmount[2] = PrepmtPurchLine."Amount Including VAT")            then                Prepmt100PctVATRoundingAmt := 0;            PricesInclVATRoundingAmount[1] := 0;        end;        if ((TotalRoundingAmount[2] <> 0) or FinalInvoice) and (TotalRoundingAmount[1] = 0) then begin            if (PrepmtPurchLine."Prepayment %" = 100) and (PrepmtPurchLine."Prepmt. Amount Inv. (LCY)" = 0) then                Prepmt100PctVATRoundingAmt += TotalRoundingAmount[2];            if (PrepmtPurchLine."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;        PrepmtPurchLine."Prepmt. VAT Amount Inv. (LCY)" := -(TotalRoundingAmount[2] + Prepmt100PctVATRoundingAmt);        NewAmountIncludingVAT := PrepmtPurchLine.Amount - (TotalPrepmtAmount[2] + TotalRoundingAmount[2]);        if (PricesInclVATRoundingAmount[1] = 0) and (PricesInclVATRoundingAmount[2] = 0) or           (PrepmtPurchLine."Currency Code" <> '') and FinalInvoice        then            TotalPurchLineLCY."Amount Including VAT" -= (PrepmtPurchLine."Amount Including VAT" - NewAmountIncludingVAT + Prepmt100PctVATRoundingAmt);        if PrepmtPurchLine."Currency Code" = '' then            TotalPurchLine."Amount Including VAT" := TotalPurchLineLCY."Amount Including VAT";        PrepmtPurchLine."Amount Including VAT" := NewAmountIncludingVAT;        if FinalInvoice and (TotalPurchLine.Amount = 0) and (TotalPurchLine."Amount Including VAT" <> 0) and           (Abs(TotalPurchLine."Amount Including VAT") <= Currency."Amount Rounding Precision")        then begin            PrepmtPurchLine."Amount Including VAT" -= TotalPurchLineLCY."Amount Including VAT";            TotalPurchLine."Amount Including VAT" := 0;            TotalPurchLineLCY."Amount Including VAT" := 0;        end;        OnAfterUpdatePrepmtPurchLineWithRounding(          PrepmtPurchLine, TotalRoundingAmount, TotalPrepmtAmount, FinalInvoice, PricesInclVATRoundingAmount,          TotalPurchLine, TotalPurchLineLCY);    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 GetPurchOrderLine(var PurchOrderLine: Record "Purchase Line"; PurchLine: Record "Purchase Line")    var        PurchRcptLine: Record "Purch. Rcpt. Line";    begin        PurchRcptLine.Get(PurchLine."Receipt No.", PurchLine."Receipt Line No.");        PurchOrderLine.Get(          PurchOrderLine."Document Type"::Order,          PurchRcptLine."Order No.", PurchRcptLine."Order Line No.");        PurchOrderLine."Prepmt Amt to Deduct" := PurchLine."Prepmt Amt to Deduct";        OnAfterGetPurchOrderLine(PurchOrderLine, PurchLine, PurchRcptLine);    end;    /// <summary>    ///  Decrements the prepayment amount invoiced in LCY and the prepayment VAT amount invoiced in LCY for a given purchase line.    /// </summary>    /// <param name="PurchaseHeader">The Purchase Header of the document being posted.</param>    /// <param name="PurchaseLine">The Purchase Line of the document for which the prepayment amount is being calculated.</param>    /// <param name="PrepmtAmountInvLCY">The invoiced prepayment amount of a purchase line. The amount passed in gets reduced by the amount to be deducted.</param>    /// <param name="PrepmtVATAmountInvLCY">The invoiced prepayment VAT amount of a purchase line. The amount passed in gets reduced by the amount to be deducted.</param>    procedure DecrementPrepmtAmtInvLCY(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; var PrepmtAmountInvLCY: Decimal; var PrepmtVATAmountInvLCY: Decimal)    begin        TempPrepmtDeductLCYPurchLine.Reset();        if TempPrepmtDeductLCYPurchLine.Get(PurchaseLine."Document Type", PurchaseLine."Document No.", PurchaseLine."Line No.") then begin            PrepmtAmountInvLCY := PrepmtAmountInvLCY - TempPrepmtDeductLCYPurchLine."Prepmt. Amount Inv. (LCY)";            PrepmtVATAmountInvLCY := PrepmtVATAmountInvLCY - TempPrepmtDeductLCYPurchLine."Prepmt. VAT Amount Inv. (LCY)";        end;        OnAfterDecrementPrepmtAmtInvLCY(PurchaseHeader, PurchaseLine, PrepmtAmountInvLCY, PrepmtVATAmountInvLCY);    end;    local procedure AdjustFinalInvWith100PctPrepmt(var CombinedPurchLine: Record "Purchase Line")    var        DiffToLineDiscAmt: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeAdjustFinalInvWith100PctPrepmt(CombinedPurchLine, TempPrepmtDeductLCYPurchLine, IsHandled);        if IsHandled then            exit;        TempPrepmtDeductLCYPurchLine.Reset();        TempPrepmtDeductLCYPurchLine.SetRange("Prepayment %", 100);        if TempPrepmtDeductLCYPurchLine.FindSet(true) then            repeat                if TempPrepmtDeductLCYPurchLine.IsFinalInvoice() then begin                    DiffToLineDiscAmt := TempPrepmtDeductLCYPurchLine."Prepmt Amt to Deduct" - TempPrepmtDeductLCYPurchLine."Line Amount";                    if TempPrepmtDeductLCYPurchLine."Document Type" = TempPrepmtDeductLCYPurchLine."Document Type"::Order then                        DiffToLineDiscAmt := DiffToLineDiscAmt * TempPrepmtDeductLCYPurchLine.Quantity / TempPrepmtDeductLCYPurchLine."Qty. to Invoice";                    if DiffToLineDiscAmt <> 0 then begin                        CombinedPurchLine.Get(TempPrepmtDeductLCYPurchLine."Document Type", TempPrepmtDeductLCYPurchLine."Document No.", TempPrepmtDeductLCYPurchLine."Line No.");                        TempPrepmtDeductLCYPurchLine."Line Discount Amount" := CombinedPurchLine."Line Discount Amount" - DiffToLineDiscAmt;                        TempPrepmtDeductLCYPurchLine.Modify();                    end;                end;            until TempPrepmtDeductLCYPurchLine.Next() = 0;        TempPrepmtDeductLCYPurchLine.Reset();    end;    /// <summary>    /// Calculate outstanding line amount deducted by prepaid amount and invoice discounts    /// </summary>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    /// <remarks>    /// This calculation only applies to purchase lines that have amount prepaid in full    /// </remarks>    /// <returns>Returns the difference between line amount and amount already prepaid (including discount)</returns>    procedure GetPrepmtDiffToLineAmount(PurchLine: Record "Purchase Line"): Decimal    begin        if PurchLine."Prepayment %" = 100 then            if TempPrepmtDeductLCYPurchLine.Get(PurchLine."Document Type", PurchLine."Document No.", PurchLine."Line No.") then                exit(TempPrepmtDeductLCYPurchLine."Prepmt Amt to Deduct" + TempPrepmtDeductLCYPurchLine."Inv. Disc. Amount to Invoice" - TempPrepmtDeductLCYPurchLine."Line Amount");        exit(0);    end;    local procedure InsertICGenJnlLine(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; var ICGenJnlLineNo: Integer)    var        ICGLAccount: Record "IC G/L Account";        Currency: Record Currency;        ICPartner: Record "IC Partner";        GenJnlLine: Record "Gen. Journal Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertICGenJnlLine(PurchHeader, PurchLine, ICGenJnlLineNo, IsHandled);        if IsHandled then            exit;        PurchHeader.TestField("Buy-from IC Partner Code", '');        PurchHeader.TestField("Pay-to IC Partner Code", '');        PurchLine.TestField("IC Partner Ref. Type", PurchLine."IC Partner Ref. Type"::"G/L Account");        ICGLAccount.Get(PurchLine."IC Partner Reference");        ICGenJnlLineNo := ICGenJnlLineNo + 1;        TempICGenJnlLine.InitNewLine(            PurchHeader."Posting Date", PurchHeader."Document Date", PurchHeader."VAT Reporting Date", PurchHeader."Posting Description",            PurchLine."Shortcut Dimension 1 Code", PurchLine."Shortcut Dimension 2 Code", PurchLine."Dimension Set ID",            PurchHeader."Reason Code");        TempICGenJnlLine."Line No." := ICGenJnlLineNo;        TempICGenJnlLine.CopyDocumentFields(GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, PurchHeader."Posting No. Series");        OnInsertICGenJnlLineOnAfterCopyDocumentFields(PurchHeader, PurchLine, TempICGenJnlLine);        TempICGenJnlLine."Account Type" := TempICGenJnlLine."Account Type"::"IC Partner";        TempICGenJnlLine.Validate("Account No.", PurchLine."IC Partner Code");        TempICGenJnlLine."Source Currency Code" := PurchHeader."Currency Code";        TempICGenJnlLine."Source Currency Amount" := TempICGenJnlLine.Amount;        TempICGenJnlLine.Correction := PurchHeader.Correction;        TempICGenJnlLine."Country/Region Code" := PurchHeader."VAT Country/Region Code";        TempICGenJnlLine."Source Type" := GenJnlLine."Source Type"::Vendor;        TempICGenJnlLine."Source No." := PurchHeader."Pay-to Vendor No.";        TempICGenJnlLine."Source Line No." := PurchLine."Line No.";        TempICGenJnlLine.Validate("Bal. Account Type", TempICGenJnlLine."Bal. Account Type"::"G/L Account");        TempICGenJnlLine.Validate("Bal. Account No.", PurchLine."No.");        TempICGenJnlLine."Shortcut Dimension 1 Code" := PurchLine."Shortcut Dimension 1 Code";        TempICGenJnlLine."Shortcut Dimension 2 Code" := PurchLine."Shortcut Dimension 2 Code";        TempICGenJnlLine."Dimension Set ID" := PurchLine."Dimension Set ID";        ValidateICPartnerBusPostingGroups(PurchLine);        TempICGenJnlLine.Validate("Bal. VAT Prod. Posting Group", PurchLine."VAT Prod. Posting Group");        TempICGenJnlLine."IC Partner Code" := PurchLine."IC Partner Code";        TempICGenJnlLine."IC Account Type" := TempICGenJnlLine."IC Account Type"::"G/L Account";        TempICGenJnlLine."IC Account No." := PurchLine."IC Partner Reference";        TempICGenJnlLine."IC Direction" := TempICGenJnlLine."IC Direction"::Outgoing;        ICPartner.Get(PurchLine."IC Partner Code");        if ICPartner."Cost Distribution in LCY" and (PurchLine."Currency Code" <> '') then begin            TempICGenJnlLine."Currency Code" := '';            TempICGenJnlLine."Currency Factor" := 0;            Currency.Get(PurchLine."Currency Code");            if PurchHeader.IsCreditDocType() then                TempICGenJnlLine.Amount :=                  -Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      PurchHeader."Posting Date", PurchLine."Currency Code",                      PurchLine.Amount, PurchHeader."Currency Factor"))            else                TempICGenJnlLine.Amount :=                  Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      PurchHeader."Posting Date", PurchLine."Currency Code",                      PurchLine.Amount, PurchHeader."Currency Factor"));        end else begin            Currency.InitRoundingPrecision();            TempICGenJnlLine."Currency Code" := PurchHeader."Currency Code";            TempICGenJnlLine."Currency Factor" := PurchHeader."Currency Factor";            if PurchHeader.IsCreditDocType() then                TempICGenJnlLine.Amount := -PurchLine.Amount            else                TempICGenJnlLine.Amount := PurchLine.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" := PurchLine.GetJnlTemplateName();        OnInsertICGenJnlLineOnBeforeICGenJnlLineInsert(TempICGenJnlLine, PurchHeader, PurchLine, SuppressCommit);        TempICGenJnlLine.Insert();    end;    local procedure ValidateICPartnerBusPostingGroups(var PurchaseLine: Record "Purchase Line")    var        Customer: Record Customer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeValidateICPartnerBusPostingGroups(TempICGenJnlLine, PurchaseLine, IsHandled);        if IsHandled then            exit;        Customer.SetCurrentKey("IC Partner Code");        Customer.SetRange("IC Partner Code", PurchaseLine."IC Partner Code");        if Customer.FindFirst() then begin            TempICGenJnlLine.Validate("Bal. Gen. Bus. Posting Group", Customer."Gen. Bus. Posting Group");            TempICGenJnlLine.Validate("Bal. VAT Bus. Posting Group", Customer."VAT Bus. Posting Group");        end;    end;    local procedure PostICGenJnl()    var        ICInboxOutboxMgt: Codeunit ICInboxOutboxMgt;        ICOutboxExport: Codeunit "IC Outbox Export";        ICTransactionNo: Integer;    begin        TempICGenJnlLine.Reset();        if TempICGenJnlLine.Find('-') then            repeat                ICTransactionNo := ICInboxOutboxMgt.CreateOutboxJnlTransaction(TempICGenJnlLine, false);                ICInboxOutboxMgt.CreateOutboxJnlLine(ICTransactionNo, 1, TempICGenJnlLine);                ICOutboxExport.ProcessAutoSendOutboxTransactionNo(ICTransactionNo);                if TempICGenJnlLine.Amount <> 0 then                    GenJnlPostLine.RunWithCheck(TempICGenJnlLine);            until TempICGenJnlLine.Next() = 0;    end;    local procedure TestGetRcptPPmtAmtToDeduct()    var        TempPurchLine: Record "Purchase Line" temporary;        TempRcvdPurchLine: Record "Purchase Line" temporary;        TempTotalPurchLine: Record "Purchase Line" temporary;        TempPurchRcptLine: Record "Purch. Rcpt. Line" temporary;        PurchRcptLine: Record "Purch. Rcpt. Line";        PurchaseOrderLine: Record "Purchase Line";        MaxAmtToDeduct: Decimal;    begin        ResetTempLines(TempPurchLine);        TempPurchLine.SetFilter(Quantity, '>0');        TempPurchLine.SetFilter("Qty. to Invoice", '>0');        TempPurchLine.SetFilter("Receipt No.", '<>%1', '');        TempPurchLine.SetFilter("Prepmt Amt to Deduct", '<>0');        if TempPurchLine.IsEmpty() then            exit;        TempPurchLine.SetRange("Prepmt Amt to Deduct");        if TempPurchLine.FindSet() then            repeat                if PurchRcptLine.Get(TempPurchLine."Receipt No.", TempPurchLine."Receipt Line No.") then begin                    TempRcvdPurchLine := TempPurchLine;                    TempRcvdPurchLine.Insert();                    TempPurchRcptLine := PurchRcptLine;                    if TempPurchRcptLine.Insert() then;                    if not TempTotalPurchLine.Get(TempPurchLine."Document Type"::Order, PurchRcptLine."Order No.", PurchRcptLine."Order Line No.")                    then begin                        TempTotalPurchLine.Init();                        TempTotalPurchLine."Document Type" := TempPurchLine."Document Type"::Order;                        TempTotalPurchLine."Document No." := PurchRcptLine."Order No.";                        TempTotalPurchLine."Line No." := PurchRcptLine."Order Line No.";                        TempTotalPurchLine.Insert();                    end;                    TempTotalPurchLine."Qty. to Invoice" := TempTotalPurchLine."Qty. to Invoice" + TempPurchLine."Qty. to Invoice";                    TempTotalPurchLine."Prepmt Amt to Deduct" := TempTotalPurchLine."Prepmt Amt to Deduct" + TempPurchLine."Prepmt Amt to Deduct";                    AdjustInvLineWith100PctPrepmt(TempPurchLine, TempTotalPurchLine);                    TempTotalPurchLine.Modify();                end;            until TempPurchLine.Next() = 0;        if TempRcvdPurchLine.FindSet() then            repeat                if TempPurchRcptLine.Get(TempRcvdPurchLine."Receipt No.", TempRcvdPurchLine."Receipt Line No.") then                    if PurchaseOrderLine.Get(                         TempRcvdPurchLine."Document Type"::Order, TempPurchRcptLine."Order No.", TempPurchRcptLine."Order Line No.")                    then                        if TempTotalPurchLine.Get(                             TempRcvdPurchLine."Document Type"::Order, TempPurchRcptLine."Order No.", TempPurchRcptLine."Order Line No.")                        then begin                            MaxAmtToDeduct := PurchaseOrderLine."Prepmt. Amt. Inv." - PurchaseOrderLine."Prepmt Amt Deducted";                            if TempTotalPurchLine."Prepmt Amt to Deduct" > MaxAmtToDeduct then                                Error(PrepAmountToDeductToBigErr, TempPurchLine.FieldCaption("Prepmt Amt to Deduct"), MaxAmtToDeduct);                            if (TempTotalPurchLine."Qty. to Invoice" = PurchaseOrderLine.Quantity - PurchaseOrderLine."Quantity Invoiced") and                               (PurchaseOrderLine."Prepmt Amt to Deduct" <> MaxAmtToDeduct)                            then                                Error(PrepAmountToDeductToSmallErr, TempPurchLine.FieldCaption("Prepmt Amt to Deduct"), MaxAmtToDeduct);                        end;            until TempRcvdPurchLine.Next() = 0;    end;    local procedure AdjustInvLineWith100PctPrepmt(var PurchInvoiceLine: Record "Purchase Line"; var TempTotalPurchLine: Record "Purchase Line" temporary)    var        PurchOrderLine: Record "Purchase Line";        DiffAmtToDeduct: Decimal;    begin        if PurchInvoiceLine."Prepayment %" = 100 then begin            PurchOrderLine.Get(TempTotalPurchLine."Document Type", TempTotalPurchLine."Document No.", TempTotalPurchLine."Line No.");            if TempTotalPurchLine."Qty. to Invoice" = PurchOrderLine.Quantity - PurchOrderLine."Quantity Invoiced" then begin                DiffAmtToDeduct :=                  PurchOrderLine."Prepmt. Amt. Inv." - PurchOrderLine."Prepmt Amt Deducted" - TempTotalPurchLine."Prepmt Amt to Deduct";                if DiffAmtToDeduct <> 0 then begin                    PurchInvoiceLine."Prepmt Amt to Deduct" := PurchInvoiceLine."Prepmt Amt to Deduct" + DiffAmtToDeduct;                    PurchInvoiceLine."Line Amount" := PurchInvoiceLine."Prepmt Amt to Deduct";                    PurchInvoiceLine."Line Discount Amount" := PurchInvoiceLine."Line Discount Amount" - DiffAmtToDeduct;                    ModifyTempLine(PurchInvoiceLine);                    TempTotalPurchLine."Prepmt Amt to Deduct" := TempTotalPurchLine."Prepmt Amt to Deduct" + DiffAmtToDeduct;                end;            end;        end;    end;    /// <summary>    /// Archives unposted purchase document    /// </summary>    /// <remarks>    /// Only Purchase Orders and Purchase Return Orders can be archived    /// Archiving must be enabled in Purchase Setup    /// When archiving purchase line associated with deferrals, deferral amounts are rounded     /// </remarks>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    procedure ArchiveUnpostedOrder(var PurchHeader: Record "Purchase Header")    var        PurchLine: Record "Purchase Line";        ArchiveManagement: Codeunit ArchiveManagement;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeArchiveUnpostedOrder(PurchHeader, IsHandled, OrderArchived, PreviewMode);        if IsHandled then            exit;        if not (PurchHeader."Document Type" in [PurchHeader."Document Type"::Order, PurchHeader."Document Type"::"Return Order"]) then            exit;        GetPurchSetup();        if (PurchHeader."Document Type" = PurchHeader."Document Type"::Order) and not PurchSetup."Archive Orders" then            exit;        if (PurchHeader."Document Type" = PurchHeader."Document Type"::"Return Order") and not PurchSetup."Archive Return Orders" then            exit;        PurchLine.Reset();        PurchLine.SetRange("Document Type", PurchHeader."Document Type");        PurchLine.SetRange("Document No.", PurchHeader."No.");        PurchLine.SetFilter(Quantity, '<>0');        if PurchHeader."Document Type" = PurchHeader."Document Type"::Order then            PurchLine.SetFilter("Qty. to Receive", '<>0')        else            PurchLine.SetFilter("Return Qty. to Ship", '<>0');        if not PurchLine.IsEmpty() and not PreviewMode then begin            ArchiveManagement.RoundPurchaseDeferralsForArchive(PurchHeader, PurchLine);            ArchiveManagement.ArchPurchDocumentNoConfirm(PurchHeader);            OrderArchived := true;        end;    end;    local procedure PostItemJnlLineJobConsumption(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; ItemJournalLine: Record "Item Journal Line"; var TempPurchReservEntry: Record "Reservation Entry" temporary; QtyToBeInvoiced: Decimal; QtyToBeReceived: Decimal; var TempTrackingSpecification: Record "Tracking Specification" temporary; PurchItemLedgEntryNo: Integer)    var        ItemLedgEntry: Record "Item Ledger Entry";        TempReservationEntry: Record "Reservation Entry" temporary;        JobPlanningLine: Record "Job Planning Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnPostItemJnlLineJobConsumption(          PurchHeader, PurchLine, ItemJournalLine, TempPurchReservEntry, QtyToBeInvoiced, QtyToBeReceived,          TempTrackingSpecification, PurchItemLedgEntryNo, IsHandled, ItemJnlPostLine, PurchInvHeader, PurchCrMemoHeader, SrcCode);        if IsHandled then            exit;        if PurchLine."Job No." <> '' then begin            ItemJournalLine."Entry Type" := ItemJournalLine."Entry Type"::"Negative Adjmt.";            Job.Get(PurchLine."Job No.");            ItemJournalLine."Source No." := Job."Bill-to Customer No.";            if PurchHeader.Invoice then begin                ItemLedgEntry.Reset();                ItemLedgEntry.SetRange("Document Type", ItemLedgEntry."Document Type"::"Purchase Return Shipment");                if PurchLine."Return Shipment No." <> '' then                    ItemLedgEntry.SetRange("Document No.", PurchLine."Return Shipment No.")                else                    ItemLedgEntry.SetRange("Document No.", PurchHeader."Last Return Shipment No.");                ItemLedgEntry.SetRange("Item No.", PurchLine."No.");                ItemLedgEntry.SetRange("Entry Type", ItemLedgEntry."Entry Type"::"Negative Adjmt.");                ItemLedgEntry.SetRange("Completely Invoiced", false);                OnPostItemJnlLineJobConsumptionOnAfterItemLedgEntrySetFilters(ItemLedgEntry, PurchLine, ItemJournalLine);                if ItemLedgEntry.FindFirst() then                    ItemJournalLine."Item Shpt. Entry No." := ItemLedgEntry."Entry No.";            end;            JobPlanningLine.SetLoadFields("Job Contract Entry No.");            if JobPlanningLine.Get(PurchLine."Job No.", PurchLine."Job Task No.", PurchLine."Job Planning Line No.") then                ItemJournalLine."Job Contract Entry No." := JobPlanningLine."Job Contract Entry No.";            ItemJournalLine."Source Type" := ItemJournalLine."Source Type"::Customer;            ItemJournalLine."Discount Amount" := 0;            GetAppliedItemLedgEntryNo(ItemJournalLine, PurchLine."Quantity Received");            if QtyToBeReceived <> 0 then                CopyJobConsumptionReservation(                  TempReservationEntry, TempPurchReservEntry, ItemJournalLine, TempTrackingSpecification,                  PurchItemLedgEntryNo, PurchLine.IsNonInventoriableItem());            OnPostItemJnlLineJobConsumptionOnBeforeRunItemJnlPostLineWithReservation(ItemJournalLine, TempReservationEntry, PurchLine);            RunItemJnlPostLineWithReservation(ItemJournalLine, TempReservationEntry);            IsHandled := false;            OnPostItemJnlLineJobConsumptionOnBeforeJobPost(                PurchHeader, PurchInvHeader, PurchCrMemoHeader, PurchRcptHeader, ReturnShptHeader, PurchLine, SrcCode, QtyToBeReceived, IsHandled, QtyToBeInvoiced);            if IsHandled then                exit;            if PurchLine."Job Line Type" = PurchLine."Job Line Type"::" " then                ValidateMatchingJobPlanningLine(PurchLine);            if QtyToBeInvoiced <> 0 then begin                PurchLine."Qty. to Invoice" := QtyToBeInvoiced;                IsHandled := false;                OnPostItemJnlLineJobConsumptionOnBeforePrepareJobLine(PurchLine, QtyToBeInvoiced, PurchHeader, PurchLineACY, IsHandled);                if not IsHandled then                    InvoicePostingInterface.PrepareJobLine(PurchHeader, PurchLine, PurchLineACY);            end;        end;    end;    local procedure CopyJobConsumptionReservation(var TempReservEntryJobCons: Record "Reservation Entry" temporary; var TempReservEntryPurchase: Record "Reservation Entry" temporary; var ItemJournalLine: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; PurchItemLedgEntryNo: Integer; NonInventoriableItem: Boolean)    var        NextReservationEntryNo: Integer;    begin        // Item tracking for consumption        NextReservationEntryNo := 1;        if TempReservEntryPurchase.FindSet() then            repeat                TempReservEntryJobCons := TempReservEntryPurchase;                TempReservEntryJobCons."Entry No." := NextReservationEntryNo;                TempReservEntryJobCons.Positive := not TempReservEntryJobCons.Positive;                TempReservEntryJobCons."Quantity (Base)" := -TempReservEntryJobCons."Quantity (Base)";                TempReservEntryJobCons."Shipment Date" := TempReservEntryJobCons."Expected Receipt Date";                TempReservEntryJobCons."Expected Receipt Date" := 0D;                TempReservEntryJobCons.Quantity := -TempReservEntryJobCons.Quantity;                TempReservEntryJobCons."Qty. to Handle (Base)" := -TempReservEntryJobCons."Qty. to Handle (Base)";                TempReservEntryJobCons."Qty. to Invoice (Base)" := -TempReservEntryJobCons."Qty. to Invoice (Base)";                TempReservEntryJobCons."Source Subtype" := ItemJournalLine."Entry Type".AsInteger();                TempReservEntryJobCons."Source Ref. No." := ItemJournalLine."Line No.";                UpdateJobConsumptionReservationApplToItemEntry(TempReservEntryJobCons, ItemJournalLine, TempTrackingSpecification, NonInventoriableItem);                TempTrackingSpecification.Reset();                TempReservEntryJobCons.Insert();                NextReservationEntryNo := NextReservationEntryNo + 1;            until TempReservEntryPurchase.Next() = 0        else            if not (ItemJournalLine.IsPurchaseReturn() or NonInventoriableItem) then                ItemJournalLine."Applies-to Entry" := PurchItemLedgEntryNo;    end;    local procedure UpdateJobConsumptionReservationApplToItemEntry(var TempReservEntryJobCons: Record "Reservation Entry" temporary; var ItemJournalLine: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; NonInventoriableItem: Boolean)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateJobConsumptionReservationApplToItemEntry(TempReservEntryJobCons, ItemJournalLine, NonInventoriableItem, IsHandled);        if IsHandled then            exit;        if not (ItemJournalLine.IsPurchaseReturn() or NonInventoriableItem) then begin            TempTrackingSpecification.SetRange("Serial No.", TempReservEntryJobCons."Serial No.");            TempTrackingSpecification.SetRange("Lot No.", TempReservEntryJobCons."Lot No.");            TempTrackingSpecification.SetRange("Package No.", TempReservEntryJobCons."Package No.");            if TempTrackingSpecification.FindFirst() then                TempReservEntryJobCons."Appl.-to Item Entry" := TempTrackingSpecification."Item Ledger Entry No.";        end;    end;    local procedure GetAppliedItemLedgEntryNo(var ItemJournalLine: Record "Item Journal Line"; QtyReceived: Decimal)    var        Item: Record Item;        ItemLedgerEntry: Record "Item Ledger Entry";    begin        Item.Get(ItemJournalLine."Item No.");        if Item.Type = Item.Type::Inventory then begin            if QtyReceived > 0 then                GetAppliedOutboundItemLedgEntryNo(ItemJournalLine)            else                if QtyReceived < 0 then                    GetAppliedInboundItemLedgEntryNo(ItemJournalLine);        end else            if ItemJournalLine."Item Shpt. Entry No." > 0 then begin                ItemLedgerEntry.Get(ItemJournalLine."Item Shpt. Entry No.");                ItemLedgerEntry.SetRange("Document Type", ItemLedgerEntry."Document Type");                ItemLedgerEntry.SetRange("Document No.", ItemLedgerEntry."Document No.");                ItemLedgerEntry.SetRange("Document Line No.", ItemLedgerEntry."Document Line No.");                ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Negative Adjmt.");                ItemLedgerEntry.SetRange("Item No.", ItemLedgerEntry."Item No.");                ItemLedgerEntry.SetRange("Completely Invoiced", false);                if ItemLedgerEntry.FindFirst() then                    ItemJournalLine."Item Shpt. Entry No." := ItemLedgerEntry."Entry No."            end;    end;    local procedure GetAppliedOutboundItemLedgEntryNo(var ItemJnlLine: Record "Item Journal Line")    var        ItemApplicationEntry: Record "Item Application Entry";    begin        ItemApplicationEntry.SetRange("Inbound Item Entry No.", ItemJnlLine."Item Shpt. Entry No.");        if ItemApplicationEntry.FindLast() then            ItemJnlLine."Item Shpt. Entry No." := ItemApplicationEntry."Outbound Item Entry No.";        OnAfterGetAppliedOutboundItemLedgEntryNo(ItemJnlLine, ItemApplicationEntry);    end;    local procedure GetAppliedInboundItemLedgEntryNo(var ItemJnlLine: Record "Item Journal Line")    var        ItemApplicationEntry: Record "Item Application Entry";    begin        ItemApplicationEntry.SetRange("Outbound Item Entry No.", ItemJnlLine."Item Shpt. Entry No.");        if ItemApplicationEntry.FindLast() then            ItemJnlLine."Item Shpt. Entry No." := ItemApplicationEntry."Inbound Item Entry No.";    end;    local procedure ItemLedgerEntryExist(PurchLine2: Record "Purchase Line"; ReceiveOrShip: Boolean): Boolean    var        HasItemLedgerEntry: Boolean;    begin        if ReceiveOrShip then            // item ledger entry will be created during posting in this transaction            HasItemLedgerEntry :=            ((PurchLine2."Qty. to Receive" + PurchLine2."Quantity Received") <> 0) or            ((PurchLine2."Qty. to Invoice" + PurchLine2."Quantity Invoiced") <> 0) or            ((PurchLine2."Return Qty. to Ship" + PurchLine2."Return Qty. Shipped") <> 0)        else            // item ledger entry must already exist            HasItemLedgerEntry :=            (PurchLine2."Quantity Received" <> 0) or            (PurchLine2."Return Qty. Shipped" <> 0);        exit(HasItemLedgerEntry);    end;    local procedure LockTables(var PurchHeader: Record "Purchase Header")    var        PurchLine: Record "Purchase Line";        SalesLine: Record "Sales Line";        InventorySetup: Record "Inventory Setup";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeLockTables(PurchHeader, PreviewMode, SuppressCommit, IsHandled, TempPurchLineGlobal);        if not IsHandled then            exit;        PurchLine.LockTable();        SalesLine.LockTable();        if InventorySetup.UseLegacyPosting() and not InventorySetup.OptimGLEntLockForMultiuserEnv() then begin            GLEntry.LockTable();            GLEntry.GetLastEntryNo();        end;    end;    local procedure "MAX"(number1: Integer; number2: Integer): Integer    begin        if number1 > number2 then            exit(number1);        exit(number2);    end;    /// <summary>    /// Recalculates and updates Direct Unit Cost of the purchase line related to a job    /// </summary>    /// <remarks>    /// PurchLine2 should have a job no. specified    /// When purchase document has prices with VAT and VAT Posting Setup on the purchase line is not "Full VAT", field "Direct Unit Cost" is re-calculated. Otherwise it's 0 (zero)    /// </remarks>    /// <param name="JobPurchLine2">Return Value: Record to store information of purchase line related to a job</param>    /// <param name="PurchLine2">The purchase line of the document that is being posted.</param>    /// <param name="PricesIncludingVAT">Specifies if the purchase document that is being posted has prices with VAT</param>    procedure CreateJobPurchLine(var JobPurchLine2: Record "Purchase Line"; PurchLine2: Record "Purchase Line"; PricesIncludingVAT: Boolean)    begin        JobPurchLine2 := PurchLine2;        if PricesIncludingVAT then            if JobPurchLine2."VAT Calculation Type" = JobPurchLine2."VAT Calculation Type"::"Full VAT" then                JobPurchLine2."Direct Unit Cost" := 0            else                JobPurchLine2."Direct Unit Cost" := JobPurchLine2."Direct Unit Cost" / (1 + JobPurchLine2."VAT %" / 100);        OnAfterCreateJobPurchLine(JobPurchLine2, PurchLine2);    end;    local procedure RevertWarehouseEntry(var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; JobNo: Code[20]; PostJobConsumptionBeforePurch: Boolean): Boolean    var        IsHandled: Boolean;        Result: Boolean;    begin        IsHandled := false;        OnBeforeRevertWarehouseEntry(TempWhseJnlLine, JobNo, PostJobConsumptionBeforePurch, Result, IsHandled);        if IsHandled then            exit(Result);        if PostJobConsumptionBeforePurch or (JobNo = '') then            exit(false);        TempWhseJnlLine."Entry Type" := TempWhseJnlLine."Entry Type"::"Negative Adjmt.";        TempWhseJnlLine.Quantity := -TempWhseJnlLine.Quantity;        TempWhseJnlLine."Qty. (Base)" := -TempWhseJnlLine."Qty. (Base)";        TempWhseJnlLine."From Bin Code" := TempWhseJnlLine."To Bin Code";        TempWhseJnlLine."To Bin Code" := '';        OnAfterRevertWarehouseEntry(TempWhseJnlLine);        exit(true);    end;    local procedure CreatePositiveEntry(WhseJnlLine: Record "Warehouse Journal Line"; JobNo: Code[20]; PostJobConsumptionBeforePurch: Boolean) Result: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreatePositiveEntry(WhseJnlLine, JobNo, Result, IsHandled);        if IsHandled then            exit(Result);        if not PostJobConsumptionBeforePurch and (JobNo = '') then            exit(false);        WhseJnlLine.Quantity := -WhseJnlLine.Quantity;        WhseJnlLine."Qty. (Base)" := -WhseJnlLine."Qty. (Base)";        WhseJnlLine."Qty. (Absolute)" := -WhseJnlLine."Qty. (Absolute)";        WhseJnlLine."To Bin Code" := WhseJnlLine."From Bin Code";        WhseJnlLine."From Bin Code" := '';        OnCreatePositiveOnBeforeWhseJnlPostLine(WhseJnlLine);        WhseJnlPostLine.Run(WhseJnlLine);        exit(true);    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(ItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)")    var        PurchLineForCharge: Record "Purchase Line";        IsHandled: Boolean;    begin        OnBeforeCheckItemCharge(ItemChargeAssignmentPurch, IsHandled);        if IsHandled then            exit;        case ItemChargeAssignmentPurch."Applies-to Doc. Type" of            ItemChargeAssignmentPurch."Applies-to Doc. Type"::Order,              ItemChargeAssignmentPurch."Applies-to Doc. Type"::Invoice:                if PurchLineForCharge.Get(ItemChargeAssignmentPurch."Applies-to Doc. Type", ItemChargeAssignmentPurch."Applies-to Doc. No.", ItemChargeAssignmentPurch."Applies-to Doc. Line No.") then                    if (PurchLineForCharge."Quantity (Base)" = PurchLineForCharge."Qty. Received (Base)") and                       (PurchLineForCharge."Qty. Rcd. Not Invoiced (Base)" = 0)                    then                        Error(ReassignItemChargeErr);            ItemChargeAssignmentPurch."Applies-to Doc. Type"::"Return Order",              ItemChargeAssignmentPurch."Applies-to Doc. Type"::"Credit Memo":                if PurchLineForCharge.Get(ItemChargeAssignmentPurch."Applies-to Doc. Type", ItemChargeAssignmentPurch."Applies-to Doc. No.", ItemChargeAssignmentPurch."Applies-to Doc. Line No.") then                    if (PurchLineForCharge."Quantity (Base)" = PurchLineForCharge."Return Qty. Shipped (Base)") and                       (PurchLineForCharge."Ret. Qty. Shpd Not Invd.(Base)" = 0)                    then                        Error(ReassignItemChargeErr);        end;    end;    /// <summary>    /// Opens progress dialog window and updates it with purhcase document information (document type and number)    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    procedure InitProgressWindow(PurchHeader: Record "Purchase Header")    begin        if PurchHeader.Invoice then            Window.Open(              '#1#################################\\' +              PostingLinesMsg +              PostingPurchasesAndVATMsg +              PostingVendorsMsg +              PostingBalAccountMsg)        else            Window.Open(              '#1############################\\' +              PostingLines2Msg);        Window.Update(1, StrSubstNo('%1 %2', PurchHeader."Document Type", PurchHeader."No."));    end;    /// <summary>    /// Sets global variable PreviewMode    /// </summary>    /// <param name="NewPreviewMode">New value for preview mode</param>    procedure SetPreviewMode(NewPreviewMode: Boolean)    begin        PreviewMode := NewPreviewMode;    end;    /// <summary>    /// Sets global variable CalledBy    /// </summary>    /// <remarks>    /// CalledBy is used to determine if posting was invoked by another object    /// </remarks>    /// <param name="NewCalledBy">New value for Called by</param>    procedure SetCalledBy(NewCalledBy: Integer)    begin        CalledBy := NewCalledBy;    end;    local procedure UpdateInvoicedQtyOnPurchRcptLine(var PurchInvHeader: Record "Purch. Inv. Header"; var PurchRcptLine: Record "Purch. Rcpt. Line"; var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary)    var        IsHandled: Boolean;    begin        OnBeforeUpdateInvoicedQtyOnPurchRcptLine(          PurchRcptLine, QtyToBeInvoiced, QtyToBeInvoicedBase, SuppressCommit, PurchInvHeader, PurchaseHeader, PurchaseLine);        PurchRcptLine."Quantity Invoiced" := PurchRcptLine."Quantity Invoiced" + QtyToBeInvoiced;        PurchRcptLine."Qty. Invoiced (Base)" := PurchRcptLine."Qty. Invoiced (Base)" + QtyToBeInvoicedBase;        PurchRcptLine."Qty. Rcd. Not Invoiced" := PurchRcptLine.Quantity - PurchRcptLine."Quantity Invoiced";        IsHandled := false;        OnBeforeModifyInvoicedQtyOnPurchRcptLine(PurchRcptLine, IsHandled);        if not IsHandled then            PurchRcptLine.Modify();        OnAfterUpdateInvoicedQtyOnPurchRcptLine(          PurchInvHeader, PurchRcptLine, PurchaseLine, TempTrackingSpecification, TrackingSpecificationExists,          QtyToBeInvoiced, QtyToBeInvoicedBase, PurchaseHeader, SuppressCommit);    end;    local procedure UpdateInvoicedQtyOnReturnShptLine(var ReturnShptLine: Record "Return Shipment Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    begin        ReturnShptLine."Quantity Invoiced" := ReturnShptLine."Quantity Invoiced" - QtyToBeInvoiced;        ReturnShptLine."Qty. Invoiced (Base)" := ReturnShptLine."Qty. Invoiced (Base)" - QtyToBeInvoicedBase;        ReturnShptLine."Return Qty. Shipped Not Invd." := ReturnShptLine.Quantity - ReturnShptLine."Quantity Invoiced";        ReturnShptLine.Modify();        OnAfterUpdateInvoicedQtyOnReturnShipmentLine(ReturnShptLine);    end;    local procedure UpdateQtyPerUnitOfMeasure(var PurchLine: Record "Purchase Line")    var        ItemUnitOfMeasure: Record "Item Unit of Measure";    begin        // Skip UoM validation for partially received/shipped documents and lines fetch through "Get Receipts Lines"        if (PurchLine.Type = PurchLine.Type::Item) and (PurchLine."No." <> '') and (PurchLine."Qty. Received (Base)" = 0) and (PurchLine."Receipt No." = '') and (PurchLine."Return Qty. Shipped (Base)" = 0) and (PurchLine."Return Shipment No." = '') then            PurchLine.TestField("Unit of Measure Code");        if PurchLine."Qty. per Unit of Measure" = 0 then            if (PurchLine.Type = PurchLine.Type::Item) and               ItemUnitOfMeasure.Get(PurchLine."No.", PurchLine."Unit of Measure Code")            then                PurchLine."Qty. per Unit of Measure" := ItemUnitOfMeasure."Qty. per Unit of Measure"            else                PurchLine."Qty. per Unit of Measure" := 1;    end;    local procedure UpdateQtyToBeInvoicedForReceipt(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; PurchLine: Record "Purchase Line"; PurchRcptLine: Record "Purch. Rcpt. Line"; InvoicingTrackingSpecification: Record "Tracking Specification")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateQtyToBeInvoicedForReceipt(            QtyToBeInvoiced, QtyToBeInvoicedBase, TrackingSpecificationExists, PurchLine, PurchRcptLine, InvoicingTrackingSpecification, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, IsHandled);        if IsHandled then            exit;        if PurchLine."Qty. to Invoice" * PurchRcptLine.Quantity < 0 then            PurchLine.FieldError("Qty. to Invoice", ReceiptSameSignErr);        if TrackingSpecificationExists then begin            QtyToBeInvoiced := InvoicingTrackingSpecification."Qty. to Invoice";            QtyToBeInvoicedBase := InvoicingTrackingSpecification."Qty. to Invoice (Base)";        end else            if MatchedOrderLineMgmt.IsLineMatchedToReceiptShipment(PurchLine) then                MatchedOrderLineMgmt.SetQtyToBeInvoiced(QtyToBeInvoiced, QtyToBeInvoicedBase, PurchLine, PurchRcptLine)            else begin                QtyToBeInvoiced := RemQtyToBeInvoiced - PurchLine."Qty. to Receive";                QtyToBeInvoicedBase := RemQtyToBeInvoicedBase - PurchLine."Qty. to Receive (Base)";            end;        if Abs(QtyToBeInvoiced) > Abs(PurchRcptLine.Quantity - PurchRcptLine."Quantity Invoiced") then begin            QtyToBeInvoiced := PurchRcptLine.Quantity - PurchRcptLine."Quantity Invoiced";            QtyToBeInvoicedBase := PurchRcptLine."Quantity (Base)" - PurchRcptLine."Qty. Invoiced (Base)";        end;    end;    local procedure UpdateQtyToBeInvoicedForReturnShipment(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; PurchLine: Record "Purchase Line"; ReturnShipmentLine: Record "Return Shipment Line"; InvoicingTrackingSpecification: Record "Tracking Specification")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateQtyToBeInvoicedForReturnShipment(QtyToBeInvoiced, QtyToBeInvoicedBase, TrackingSpecificationExists, PurchLine, ReturnShipmentLine, InvoicingTrackingSpecification, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, IsHandled);        if IsHandled then            exit;        if PurchLine."Qty. to Invoice" * ReturnShipmentLine.Quantity > 0 then            PurchLine.FieldError("Qty. to Invoice", ReturnShipmentSamesSignErr);        if TrackingSpecificationExists then begin            QtyToBeInvoiced := InvoicingTrackingSpecification."Qty. to Invoice";            QtyToBeInvoicedBase := InvoicingTrackingSpecification."Qty. to Invoice (Base)";        end else begin            QtyToBeInvoiced := RemQtyToBeInvoiced - PurchLine."Return Qty. to Ship";            QtyToBeInvoicedBase := RemQtyToBeInvoicedBase - PurchLine."Return Qty. to Ship (Base)";        end;        if Abs(QtyToBeInvoiced) > Abs(ReturnShipmentLine.Quantity - ReturnShipmentLine."Quantity Invoiced") then begin            QtyToBeInvoiced := ReturnShipmentLine."Quantity Invoiced" - ReturnShipmentLine.Quantity;            QtyToBeInvoicedBase := ReturnShipmentLine."Qty. Invoiced (Base)" - ReturnShipmentLine."Quantity (Base)";        end;    end;    local procedure UpdateRemainingQtyToBeInvoiced(var RemQtyToInvoiceCurrLine: Decimal; var RemQtyToInvoiceCurrLineBase: Decimal; PurchRcptLine: Record "Purch. Rcpt. Line")    begin        RemQtyToInvoiceCurrLine := PurchRcptLine.Quantity - PurchRcptLine."Quantity Invoiced";        RemQtyToInvoiceCurrLineBase := PurchRcptLine."Quantity (Base)" - PurchRcptLine."Qty. Invoiced (Base)";        if RemQtyToInvoiceCurrLine > RemQtyToBeInvoiced then begin            RemQtyToInvoiceCurrLine := RemQtyToBeInvoiced;            RemQtyToInvoiceCurrLineBase := RemQtyToBeInvoicedBase;        end;    end;    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;        exit(          GetCountryRegionCode(            SalesLine."Sell-to Customer No.",            SalesHeader."Ship-to Code",            SalesHeader."Sell-to Country/Region Code"));    end;    local procedure GetCountryRegionCode(CustNo: Code[20]; ShipToCode: Code[10]; SellToCountryRegionCode: Code[10]): Code[10]    var        ShipToAddress: Record "Ship-to Address";    begin        if ShipToCode <> '' then begin            ShipToAddress.Get(CustNo, ShipToCode);            exit(ShipToAddress."Country/Region Code");        end;        exit(SellToCountryRegionCode);    end;    local procedure CheckItemReservDisruption(PurchLine: Record "Purchase Line")    var        Item: Record Item;        ConfirmManagement: Codeunit "Confirm Management";        AvailableQty: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckItemReservDisruption(PurchLine, IsHandled);        if IsHandled then            exit;        if not PurchLine.IsCreditDocType() or (PurchLine.Type <> PurchLine.Type::Item) or not (PurchLine."Return Qty. to Ship (Base)" > 0) then            exit;        if PurchLine.Nonstock or PurchLine."Special Order" or PurchLine."Drop Shipment" or           TempSKU.Get(PurchLine."Location Code", PurchLine."No.", PurchLine."Variant Code")        then            exit;        if PurchLine.IsNonInventoriableItem() then            exit;        Item.Get(PurchLine."No.");        Item.SetRange("Location Filter", PurchLine."Location Code");        Item.SetRange("Variant Filter", PurchLine."Variant Code");        Item.CalcFields("Reserved Qty. on Inventory");        if Item."Reserved Qty. on Inventory" <= 0 then            exit;        Item.CalcFields("Net Change");        PurchLine.CalcFields("Reserved Qty. (Base)");        AvailableQty := Item."Net Change" - (Item."Reserved Qty. on Inventory" - Abs(PurchLine."Reserved Qty. (Base)"));        if (AvailableQty < PurchLine."Return Qty. to Ship (Base)") and           (Item."Reserved Qty. on Inventory" > Abs(PurchLine."Reserved Qty. (Base)"))        then begin            InsertTempSKU(PurchLine."Location Code", PurchLine."No.", PurchLine."Variant Code");            IsHandled := false;            OnCheckItemReservDisruptionOnAfterInsertTempSKU(Item, IsHandled);            if not IsHandled then                if Location.BinMandatory(PurchLine."Location Code") then begin                    Session.LogMessage('0000GKM', ItemReservDisruptionLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', PurchLinePostCategoryTok);                    if not ConfirmManagement.GetResponseOrDefault(                        StrSubstNo(                            ReservationDisruptedQst, PurchLine.FieldCaption("No."), Item."No.", PurchLine.FieldCaption("Location Code"),                            PurchLine."Location Code", PurchLine.FieldCaption("Variant Code"), PurchLine."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;    local procedure UpdatePurchLineDimSetIDFromAppliedEntry(var PurchaseLineToPost: Record "Purchase Line"; PurchaseLine: Record "Purchase Line")    var        ItemLedgerEntry: Record "Item Ledger Entry";        DimensionMgt: Codeunit DimensionManagement;        DimSetID: array[10] of Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdatePurchLineDimSetIDFromAppliedEntry(PurchaseLineToPost, PurchaseLine, IsHandled);        if IsHandled then            exit;        DimSetID[1] := PurchaseLine."Dimension Set ID";        if PurchaseLineToPost."Appl.-to Item Entry" <> 0 then begin            ItemLedgerEntry.Get(PurchaseLineToPost."Appl.-to Item Entry");            DimSetID[2] := ItemLedgerEntry."Dimension Set ID";        end;        PurchaseLineToPost."Dimension Set ID" :=            DimensionMgt.GetCombinedDimensionSetID(DimSetID, PurchaseLineToPost."Shortcut Dimension 1 Code", PurchaseLineToPost."Shortcut Dimension 2 Code");        OnAfterUpdatePurchLineDimSetIDFromAppliedEntry(PurchaseLineToPost, PurchaseLine);    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 CheckCertificateOfSupplyStatus(ReturnShptHeader: Record "Return Shipment Header"; ReturnShptLine: Record "Return Shipment Line")    var        CertificateOfSupply: Record "Certificate of Supply";        VATPostingSetup: Record "VAT Posting Setup";    begin        if ReturnShptLine.Quantity <> 0 then            if VATPostingSetup.Get(ReturnShptHeader."VAT Bus. Posting Group", ReturnShptLine."VAT Prod. Posting Group") and               VATPostingSetup."Certificate of Supply Required"            then begin                CertificateOfSupply.InitFromPurchase(ReturnShptHeader);                CertificateOfSupply.SetRequired(ReturnShptHeader."No.")            end;    end;    /// <summary>    /// When posting drop shipment, purchase document sets Certificate of Supply as required    /// </summary>    /// <remarks>    /// This procedure is only execute when there is quantity on a sales shipment line    /// "Certificate of Supply Required" must be set on VAT Posting Setup    /// If Certificate of Supply does not exists one is created    /// </remarks>    /// <param name="SalesShptHeader">Drop shipment sales header related to purchase document</param>    /// <param name="SalesShptLine">Drop shipment sales line related to purchase document</param>    procedure CheckSalesCertificateOfSupplyStatus(SalesShptHeader: Record "Sales Shipment Header"; SalesShptLine: Record "Sales Shipment Line")    var        CertificateOfSupply: Record "Certificate of Supply";        VATPostingSetup: Record "VAT Posting Setup";    begin        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 PurchHeader: Record "Purchase Header")    var        SalesShptLine: Record "Sales Shipment Line";        PurchRcptLine: Record "Purch. Rcpt. Line";        GenJnlLine: Record "Gen. Journal Line";        PostingPreviewEventHandler: Codeunit "Posting Preview Event Handler";        IsHandled: Boolean;    begin        if PreviewMode then            PostingPreviewEventHandler.PreventCommit();        IsHandled := false;        OnBeforeInsertPostedHeaders(PurchHeader, TempWhseRcptHeader, TempWhseShptHeader, GenJnlPostLine, PurchRcptHeader, IsHandled);        if not IsHandled then begin            // Insert receipt header            if PurchHeader.Receive then                if (PurchHeader."Document Type" = PurchHeader."Document Type"::Order) or                   ((PurchHeader."Document Type" = PurchHeader."Document Type"::Invoice) and PurchSetup."Receipt on Invoice")                then begin                    if DropShipOrder then begin                        PurchRcptHeader.LockTable();                        PurchRcptLine.LockTable();                        SalesShptHeader.LockTable();                        SalesShptLine.LockTable();                    end;                    InsertReceiptHeader(PurchHeader, PurchRcptHeader);                end;            // Insert return shipment header            if PurchHeader.Ship then                if (PurchHeader."Document Type" = PurchHeader."Document Type"::"Return Order") or                   ((PurchHeader."Document Type" = PurchHeader."Document Type"::"Credit Memo") and PurchSetup."Return Shipment on Credit Memo")                then                    InsertReturnShipmentHeader(PurchHeader, ReturnShptHeader);            // Insert invoice header or credit memo header            if PurchHeader.Invoice then begin                IsHandled := false;                OnInsertPostedHeadersOnAfterInvoice(PurchHeader, GenJnlLine, GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, IsHandled);                if not IsHandled then                    if PurchHeader."Document Type" in [PurchHeader."Document Type"::Order, PurchHeader."Document Type"::Invoice] then begin                        InsertInvoiceHeader(PurchHeader, PurchInvHeader);                        GenJnlLineDocType := GenJnlLine."Document Type"::Invoice;                        GenJnlLineDocNo := PurchInvHeader."No.";                        GenJnlLineExtDocNo := PurchHeader."Vendor Invoice No.";                    end else begin // Credit Memo                        InsertCrMemoHeader(PurchHeader, PurchCrMemoHeader);                        GenJnlLineDocType := GenJnlLine."Document Type"::"Credit Memo";                        GenJnlLineDocNo := PurchCrMemoHeader."No.";                        GenJnlLineExtDocNo := PurchHeader."Vendor Cr. Memo No.";                    end;                GetInvoicePostingParameters();                InvoicePostingInterface.SetParameters(InvoicePostingParameters);            end;        end;        OnAfterInsertPostedHeaders(PurchHeader, PurchRcptHeader, PurchInvHeader, PurchCrMemoHeader, ReturnShptHeader, PurchSetup, Window);    end;    local procedure InsertReceiptHeader(var PurchHeader: Record "Purchase Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header")    var        PurchCommentLine: Record "Purch. Comment Line";        RecordLinkManagement: Codeunit "Record Link Management";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertReceiptHeader(PurchHeader, PurchRcptHeader, IsHandled, SuppressCommit);        if not IsHandled then begin            PurchRcptHeader.Init();            PurchRcptHeader.TransferFields(PurchHeader);            AssignPostedDocumentNo(PurchRcptHeader."No.", PurchHeader."Receiving No.");            if PurchHeader."Document Type" = PurchHeader."Document Type"::Order then begin                PurchRcptHeader."Order No. Series" := PurchHeader."No. Series";                PurchRcptHeader."Order No." := PurchHeader."No.";            end;            PurchRcptHeader."No. Printed" := 0;            PurchRcptHeader."Source Code" := SrcCode;            PurchRcptHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(PurchRcptHeader."User ID"));            OnBeforePurchRcptHeaderInsert(PurchRcptHeader, PurchHeader, SuppressCommit, TempWhseRcptHeader, WhseReceive, TempWhseShptHeader, WhseShip);            PurchRcptHeader.Insert(true);            OnAfterPurchRcptHeaderInsert(PurchRcptHeader, PurchHeader, SuppressCommit, PreviewMode);            ApprovalsMgmt.PostApprovalEntries(PurchHeader.RecordId, PurchRcptHeader.RecordId, PurchRcptHeader."No.");            if PurchSetup."Copy Comments Order to Receipt" then begin                PurchCommentLine.CopyComments(                  PurchHeader."Document Type".AsInteger(), PurchCommentLine."Document Type"::Receipt.AsInteger(), PurchHeader."No.", PurchRcptHeader."No.");                RecordLinkManagement.CopyLinks(PurchHeader, PurchRcptHeader);            end;        end;        if WhseReceive then begin            WhseRcptHeader.Get(TempWhseRcptHeader."No.");            OnBeforeCreatePostedWhseRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, PurchHeader);            WhsePostRcpt.CreatePostedRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, PurchHeader."Receiving No.", PurchHeader."Posting Date");        end;        if WhseShip then begin            WhseShptHeader.Get(TempWhseShptHeader."No.");            OnBeforeCreatePostedWhseShptHeader(PostedWhseShptHeader, WhseShptHeader, PurchHeader);            WhsePostShpt.CreatePostedShptHeader(PostedWhseShptHeader, WhseShptHeader, PurchHeader."Receiving No.", PurchHeader."Posting Date");        end;        OnAfterInsertReceiptHeader(PurchHeader, PurchRcptHeader, TempWhseRcptHeader, WhseReceive, SuppressCommit);    end;    /// <summary>    /// Creates purchase receipt line from purchase line    /// </summary>    /// <remarks>    /// Lines are only created for purchase lines with type Item of type Inventory and there is quantity to receive    /// Posted warehouse receipt line is created from warehouse receipt line (if warehouse receipt exists)    /// </remarks>    /// <param name="PurchRcptHeader">Purchase receipt header related to purchase document being posted.</param>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    /// <param name="CostBaseAmount">Purchase line amount (in base unit of measure) to be used as base for "Item Charge Base Amount" calculation.</param>    procedure InsertReceiptLine(PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchLine: Record "Purchase Line"; CostBaseAmount: Decimal)    var        PurchRcptLine: Record "Purch. Rcpt. Line";        WhseRcptLine: Record "Warehouse Receipt Line";        WhseShptLine: Record "Warehouse Shipment Line";        ShouldGetWhseRcptLine: Boolean;        ShouldGetWhseShptLine: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertReceiptLine(PurchRcptHeader, PurchLine, CostBaseAmount, IsHandled);        if IsHandled then            exit;        PurchRcptLine.InitFromPurchLine(PurchRcptHeader, xPurchLine);        PurchRcptLine."Quantity Invoiced" := RemQtyToBeInvoiced;        PurchRcptLine."Qty. Invoiced (Base)" := RemQtyToBeInvoicedBase;        PurchRcptLine."Qty. Rcd. Not Invoiced" := PurchRcptLine.Quantity - PurchRcptLine."Quantity Invoiced";        OnInsertReceiptLineOnAfterInitPurchRcptLine(PurchRcptLine, PurchLine, ItemLedgShptEntryNo, xPurchLine, PurchRcptHeader, CostBaseAmount, PostedWhseRcptHeader, WhseRcptHeader, WhseRcptLine);        IsHandled := false;        OnInsertReceiptLineOnBeforeProcessWhseShptRcpt(PurchLine, IsHandled, CostBaseAmount, PurchRcptLine);        if not IsHandled then            if (PurchLine.Type = PurchLine.Type::Item) and (PurchLine."Qty. to Receive" <> 0) then begin                ShouldGetWhseRcptLine := WhseReceive and PurchLine.IsInventoriableItem();                OnInsertReceiptLineOnAfterCalcShouldGetWhseRcptLine(PurchRcptHeader, PurchLine, PostedWhseRcptHeader, WhseRcptHeader, CostBaseAmount, WhseReceive, WhseShip, ShouldGetWhseRcptLine, xPurchLine, PurchRcptLine);                if ShouldGetWhseRcptLine then                    if WhseRcptLine.GetWhseRcptLine(                         WhseRcptHeader."No.", DATABASE::"Purchase Line", PurchLine."Document Type".AsInteger(), PurchLine."Document No.", PurchLine."Line No.")                    then begin                        OnInsertReceiptLineOnAfterGetWhseRcptLine(WhseRcptLine, PurchRcptLine);                        CheckWhseRcptLineQtyToReceive(WhseRcptLine, PurchRcptLine);                        SaveTempWhseSplitSpec(PurchLine);                        OnInsertReceiptLineOnBeforeCreatePostedRcptLine(PurchRcptLine, WhseRcptLine, PostedWhseRcptHeader);                        WhsePostRcpt.CreatePostedRcptLine(                          WhseRcptLine, PostedWhseRcptHeader, PostedWhseRcptLine, TempWhseSplitSpecification);                    end;                ShouldGetWhseShptLine := WhseShip and PurchLine.IsInventoriableItem();                OnInsertReceiptLineOnAfterCalcShouldGetWhseShptLine(PurchRcptHeader, PurchLine, PostedWhseShptHeader, WhseShptHeader, CostBaseAmount, WhseReceive, WhseShip, ShouldGetWhseShptLine);                if ShouldGetWhseShptLine then                    if WhseShptLine.GetWhseShptLine(                         WhseShptHeader."No.", DATABASE::"Purchase Line", PurchLine."Document Type".AsInteger(), PurchLine."Document No.", PurchLine."Line No.")                    then begin                        WhseShptLine.TestField("Qty. to Ship", -PurchRcptLine.Quantity);                        SaveTempWhseSplitSpec(PurchLine);                        OnInsertReceiptLineOnBeforeCreatePostedShptLine(PurchRcptLine, WhseShptLine, PostedWhseShptHeader);                        WhsePostShpt.CreatePostedShptLine(                          WhseShptLine, PostedWhseShptHeader, PostedWhseShptLine, TempWhseSplitSpecification);                    end;                PurchRcptLine."Item Rcpt. Entry No." := InsertRcptEntryRelation(PurchRcptLine);                PurchRcptLine."Item Charge Base Amount" := Round(CostBaseAmount / PurchLine.Quantity * PurchRcptLine.Quantity);            end;        PurchRcptLineInsert(PurchRcptLine, PurchRcptHeader, PurchLine);    end;    local procedure CheckWhseRcptLineQtyToReceive(var WhseRcptLine: Record "Warehouse Receipt Line"; var PurchRcptLine: Record "Purch. Rcpt. Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckWhseRcptLineQtyToReceive(WhseRcptLine, PurchRcptLine, IsHandled);        if IsHandled then            exit;        WhseRcptLine.TestField("Qty. to Receive", PurchRcptLine.Quantity);    end;    local procedure InsertReturnShipmentHeader(var PurchHeader: Record "Purchase Header"; var ReturnShptHeader: Record "Return Shipment Header")    var        PurchCommentLine: Record "Purch. Comment Line";        RecordLinkManagement: Codeunit "Record Link Management";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertReturnShipmentHeader(PurchHeader, ReturnShptHeader, IsHandled);        if not IsHandled then begin            ReturnShptHeader.Init();            ReturnShptHeader.TransferFields(PurchHeader);            AssignPostedDocumentNo(ReturnShptHeader."No.", PurchHeader."Return Shipment No.");            if PurchHeader."Document Type" = PurchHeader."Document Type"::"Return Order" then begin                ReturnShptHeader."Return Order No. Series" := PurchHeader."No. Series";                ReturnShptHeader."Return Order No." := PurchHeader."No.";            end;            ReturnShptHeader."No. Series" := PurchHeader."Return Shipment No. Series";            ReturnShptHeader."No. Printed" := 0;            ReturnShptHeader."Source Code" := SrcCode;            ReturnShptHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(ReturnShptHeader."User ID"));            OnBeforeReturnShptHeaderInsert(ReturnShptHeader, PurchHeader, SuppressCommit, TempWhseRcptHeader, WhseReceive, TempWhseShptHeader, WhseShip);            ReturnShptHeader.Insert(true);            OnAfterReturnShptHeaderInsert(ReturnShptHeader, PurchHeader, SuppressCommit);            ApprovalsMgmt.PostApprovalEntries(PurchHeader.RecordId, ReturnShptHeader.RecordId, ReturnShptHeader."No.");            if PurchSetup."Copy Cmts Ret.Ord. to Ret.Shpt" then begin                PurchCommentLine.CopyComments(                  PurchHeader."Document Type".AsInteger(), PurchCommentLine."Document Type"::"Posted Return Shipment".AsInteger(), PurchHeader."No.", ReturnShptHeader."No.");                RecordLinkManagement.CopyLinks(PurchHeader, ReturnShptHeader);            end;        end;        if WhseShip then begin            WhseShptHeader.Get(TempWhseShptHeader."No.");            OnBeforeCreatePostedWhseShptHeader(PostedWhseShptHeader, WhseShptHeader, PurchHeader);            WhsePostShpt.CreatePostedShptHeader(PostedWhseShptHeader, WhseShptHeader, PurchHeader."Return Shipment No.", PurchHeader."Posting Date");        end;        if WhseReceive then begin            WhseRcptHeader.Get(TempWhseRcptHeader."No.");            OnBeforeCreatePostedWhseRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, PurchHeader);            WhsePostRcpt.CreatePostedRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, PurchHeader."Return Shipment No.", PurchHeader."Posting Date");        end;        OnAfterInsertReturnShipmentHeader(PurchHeader, ReturnShptHeader);    end;    local procedure InsertReturnShipmentLine(ReturnShptHeader: Record "Return Shipment Header"; PurchLine: Record "Purchase Line"; CostBaseAmount: Decimal)    var        ReturnShptLine: Record "Return Shipment Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertReturnShipmentLine(ReturnShptHeader, PurchLine, CostBaseAmount, IsHandled);        if IsHandled then            exit;        ReturnShptLine.InitFromPurchLine(ReturnShptHeader, xPurchLine);        ReturnShptLine."Quantity Invoiced" := -RemQtyToBeInvoiced;        ReturnShptLine."Qty. Invoiced (Base)" := -RemQtyToBeInvoicedBase;        ReturnShptLine."Return Qty. Shipped Not Invd." := ReturnShptLine.Quantity - ReturnShptLine."Quantity Invoiced";        OnInsertReturnShipmentLineOnAfterReturnShptLineInit(ReturnShptHeader, ReturnShptLine, PurchLine, xPurchLine, CostBaseAmount, WhseShip, WhseReceive);        CreateWhseLineFromReturnShptLine(ReturnShptLine, PurchLine, CostBaseAmount);        OnBeforeReturnShptLineInsert(ReturnShptLine, ReturnShptHeader, PurchLine, SuppressCommit);        ReturnShptLine.Insert(true);        OnAfterReturnShptLineInsert(          ReturnShptLine, ReturnShptHeader, PurchLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit,          TempWhseShptHeader, PurchCrMemoHeader, xPurchLine);        CheckCertificateOfSupplyStatus(ReturnShptHeader, ReturnShptLine);    end;    local procedure CreateWhseLineFromReturnShptLine(var ReturnShptLine: Record "Return Shipment Line"; PurchLine: Record "Purchase Line"; CostBaseAmount: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreateWhseLineFromReturnShptLine(ReturnShptLine, PurchLine, CostBaseAmount, IsHandled);        if IsHandled then            exit;        if (PurchLine.Type = PurchLine.Type::Item) and (PurchLine."Return Qty. to Ship" <> 0) then begin            if WhseShip then                CreatePostedWhseShptLine(PurchLine, ReturnShptLine);            if WhseReceive then                CreatePostedRcptLine(PurchLine, ReturnShptLine);            ReturnShptLine."Item Shpt. Entry No." := InsertReturnEntryRelation(ReturnShptLine);            ReturnShptLine."Item Charge Base Amount" := Round(CostBaseAmount / PurchLine.Quantity * ReturnShptLine.Quantity);        end;    end;    local procedure CreatePostedWhseShptLine(PurchLine: Record "Purchase Line"; ReturnShptLine: Record "Return Shipment Line")    var        WhseShptLine: Record "Warehouse Shipment Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreatePostedWhseShptLine(PurchLine, ReturnShptLine, IsHandled);        if IsHandled then            exit;        if WhseShptLine.GetWhseShptLine(            WhseShptHeader."No.", DATABASE::"Purchase Line", PurchLine."Document Type".AsInteger(), PurchLine."Document No.", PurchLine."Line No.")        then begin            OnInsertReturnShipmentLineOnAfterGetWhseShptLine(WhseShptLine, ReturnShptLine);            WhseShptLine.TestField("Qty. to Ship", ReturnShptLine.Quantity);            SaveTempWhseSplitSpec(PurchLine);            OnCreatePostedWhseShptLineOnBeforeCreatePostedShptLine(ReturnShptLine, WhseShptLine, PostedWhseShptHeader);            WhsePostShpt.CreatePostedShptLine(              WhseShptLine, PostedWhseShptHeader, PostedWhseShptLine, TempWhseSplitSpecification);        end;    end;    local procedure CreatePostedRcptLine(PurchLine: Record "Purchase Line"; ReturnShptLine: Record "Return Shipment Line")    var        WhseRcptLine: Record "Warehouse Receipt Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreatePostedRcptLine(PurchLine, ReturnShptLine, IsHandled);        if IsHandled then            exit;        if WhseRcptLine.GetWhseRcptLine(            WhseRcptHeader."No.", DATABASE::"Purchase Line", PurchLine."Document Type".AsInteger(), PurchLine."Document No.", PurchLine."Line No.")        then begin            WhseRcptLine.TestField("Qty. to Receive", -ReturnShptLine.Quantity);            SaveTempWhseSplitSpec(PurchLine);            OnCreatePostedRcptLineOnBeforeCreatePostedRcptLine(ReturnShptLine, WhseRcptLine, PostedWhseRcptHeader);            WhsePostRcpt.CreatePostedRcptLine(              WhseRcptLine, PostedWhseRcptHeader, PostedWhseRcptLine, TempWhseSplitSpecification);        end;    end;    local procedure InsertInvoiceHeader(var PurchHeader: Record "Purchase Header"; var PurchInvHeader: Record "Purch. Inv. Header")    var        PurchCommentLine: Record "Purch. Comment Line";        RecordLinkManagement: Codeunit "Record Link Management";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertInvoiceHeader(PurchHeader, PurchInvHeader, IsHandled, Window, HideProgressWindow, SrcCode, PurchCommentLine, RecordLinkManagement);        if IsHandled then            exit;        PurchInvHeader.Init();        PurchInvHeader.TransferFields(PurchHeader);        AssignPostedDocumentNo(PurchInvHeader."No.", PurchHeader."Posting No.");        if PurchHeader."Document Type" = PurchHeader."Document Type"::Order then begin            PurchInvHeader."Pre-Assigned No. Series" := '';            PurchInvHeader."Order No. Series" := PurchHeader."No. Series";            PurchInvHeader."Order No." := PurchHeader."No.";        end else begin            if PurchHeader."Posting No." = '' then                AssignPostedDocumentNo(PurchInvHeader."No.", PurchHeader."No.");            PurchInvHeader."Pre-Assigned No. Series" := PurchHeader."No. Series";            PurchInvHeader."Pre-Assigned No." := PurchHeader."No.";        end;        if GuiAllowed() and not HideProgressWindow then            Window.Update(1, StrSubstNo(InvoiceNoMsg, PurchHeader."Document Type", PurchHeader."No.", PurchInvHeader."No."));        PurchInvHeader."Creditor No." := PurchHeader."Creditor No.";        PurchInvHeader."Payment Reference" := PurchHeader."Payment Reference";        PurchInvHeader."Payment Method Code" := PurchHeader."Payment Method Code";        PurchInvHeader."Source Code" := SrcCode;        PurchInvHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(PurchInvHeader."User ID"));        PurchInvHeader."No. Printed" := 0;        OnBeforePurchInvHeaderInsert(PurchInvHeader, PurchHeader, SuppressCommit);        if PurchHeader."Document Type" = PurchHeader."Document Type"::Invoice then            PurchInvHeader."Draft Invoice SystemId" := PurchHeader.SystemId;        if PurchHeader."Remit-to Code" <> '' then            PurchInvHeader."Remit-to Code" := PurchHeader."Remit-to Code";        PurchInvHeader.Insert(true);        OnAfterPurchInvHeaderInsert(PurchInvHeader, PurchHeader, PreviewMode);        ApprovalsMgmt.PostApprovalEntries(PurchHeader.RecordId, PurchInvHeader.RecordId, PurchInvHeader."No.");        if PurchSetup."Copy Comments Order to Invoice" then begin            PurchCommentLine.CopyComments(              PurchHeader."Document Type".AsInteger(), PurchCommentLine."Document Type"::"Posted Invoice".AsInteger(), PurchHeader."No.", PurchInvHeader."No.");            IsHandled := false;            OnInsertInvoiceHeaderOnBeforeCopyLinks(PurchHeader, PurchInvHeader, IsHandled);            if not IsHandled then                RecordLinkManagement.CopyLinks(PurchHeader, PurchInvHeader);        end;        OnAfterInsertInvoiceHeader(PurchHeader, PurchInvHeader);    end;    local procedure InsertCrMemoHeader(var PurchHeader: Record "Purchase Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr.")    var        PurchCommentLine: Record "Purch. Comment Line";        RecordLinkManagement: Codeunit "Record Link Management";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInserCrMemoHeader(PurchHeader, PurchCrMemoHdr, HideProgressWindow, Window, IsHandled, SrcCode, PurchCrMemoHeader, PurchCommentLine);        if IsHandled then            exit;        PurchCrMemoHdr.Init();        PurchCrMemoHdr.TransferFields(PurchHeader);        AssignPostedDocumentNo(PurchCrMemoHdr."No.", PurchHeader."No.");        if PurchHeader."Document Type" = PurchHeader."Document Type"::"Return Order" then begin            AssignPostedDocumentNo(PurchCrMemoHdr."No.", PurchHeader."Posting No.");            PurchCrMemoHdr."Pre-Assigned No. Series" := '';            PurchCrMemoHdr."Return Order No. Series" := PurchHeader."No. Series";            PurchCrMemoHdr."Return Order No." := PurchHeader."No.";            if GuiAllowed() and not HideProgressWindow then                Window.Update(1, StrSubstNo(CreditMemoNoMsg, PurchHeader."Document Type", PurchHeader."No.", PurchCrMemoHdr."No."));        end else begin            PurchCrMemoHdr."Pre-Assigned No. Series" := PurchHeader."No. Series";            PurchCrMemoHdr."Pre-Assigned No." := PurchHeader."No.";            if PurchHeader."Posting No." <> '' then begin                AssignPostedDocumentNo(PurchCrMemoHdr."No.", PurchHeader."Posting No.");                if GuiAllowed() and not HideProgressWindow then                    Window.Update(1, StrSubstNo(CreditMemoNoMsg, PurchHeader."Document Type", PurchHeader."No.", PurchCrMemoHdr."No."));            end;        end;        PurchCrMemoHdr."Source Code" := SrcCode;        PurchCrMemoHdr."User ID" := CopyStr(UserId(), 1, MaxStrLen(PurchCrMemoHdr."User ID"));        PurchCrMemoHdr."No. Printed" := 0;        PurchCrMemoHdr."Draft Cr. Memo SystemId" := PurchCrMemoHdr.SystemId;        OnBeforePurchCrMemoHeaderInsert(PurchCrMemoHdr, PurchHeader, SuppressCommit);        PurchCrMemoHdr.Insert(true);        OnAfterPurchCrMemoHeaderInsert(PurchCrMemoHdr, PurchHeader, SuppressCommit, PreviewMode);        ApprovalsMgmt.PostApprovalEntries(PurchHeader.RecordId, PurchCrMemoHdr.RecordId, PurchCrMemoHdr."No.");        if PurchSetup."Copy Cmts Ret.Ord. to Cr. Memo" then begin            PurchCommentLine.CopyComments(              PurchHeader."Document Type".AsInteger(), PurchCommentLine."Document Type"::"Posted Credit Memo".AsInteger(), PurchHeader."No.", PurchCrMemoHdr."No.");            RecordLinkManagement.CopyLinks(PurchHeader, PurchCrMemoHdr);        end;        OnAfterInsertCrMemoHeader(PurchHeader, PurchCrMemoHdr);    end;    local procedure InsertSalesShptHeader(var SalesOrderHeader: Record "Sales Header"; var PurchHeader: Record "Purchase Header"; var SalesShptHeader: Record "Sales Shipment Header")    begin        SalesShptHeader.Init();        SalesOrderHeader.CalcFields("Work Description");        SalesShptHeader.TransferFields(SalesOrderHeader);        AssignPostedDocumentNo(SalesShptHeader."No.", SalesOrderHeader."Shipping No.");        SalesShptHeader."Order No." := SalesOrderHeader."No.";        SalesShptHeader."Posting Date" := PurchHeader."Posting Date";        SalesShptHeader."Document Date" := PurchHeader."Document Date";        SalesShptHeader."No. Printed" := 0;        OnBeforeSalesShptHeaderInsert(SalesShptHeader, SalesOrderHeader, SuppressCommit, PurchHeader);        SalesShptHeader.Insert(true);        OnAfterSalesShptHeaderInsert(SalesShptHeader, SalesOrderHeader, SuppressCommit, PurchHeader);    end;    local procedure InsertSalesShptLine(SalesShptHeader: Record "Sales Shipment Header"; SalesOrderLine: Record "Sales Line"; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer"; var SalesShptLine: Record "Sales Shipment Line")    var        IsHandled: Boolean;    begin        SalesShptLine.Init();        SalesShptLine.TransferFields(SalesOrderLine);        SalesShptLine."Posting Date" := SalesShptHeader."Posting Date";        SalesShptLine."Document No." := SalesShptHeader."No.";        SalesShptLine.Quantity := DropShptPostBuffer.Quantity;        SalesShptLine."Quantity (Base)" := DropShptPostBuffer."Quantity (Base)";        SalesShptLine."Quantity Invoiced" := 0;        SalesShptLine."Qty. Invoiced (Base)" := 0;        SalesShptLine."Order No." := SalesOrderLine."Document No.";        SalesShptLine."Order Line No." := SalesOrderLine."Line No.";        SalesShptLine."Qty. Shipped Not Invoiced" :=          SalesShptLine.Quantity - SalesShptLine."Quantity Invoiced";        if SalesShptLine.Quantity <> 0 then begin            SalesShptLine."Item Shpt. Entry No." := DropShptPostBuffer."Item Shpt. Entry No.";            SalesShptLine."Item Charge Base Amount" := SalesOrderLine."Line Amount";        end;        OnBeforeSalesShptLineInsert(SalesShptLine, SalesShptHeader, SalesOrderLine, SuppressCommit, DropShptPostBuffer, IsHandled);        if not IsHandled then            SalesShptLine.Insert();        OnAfterSalesShptLineInsert(SalesShptLine, SalesShptHeader, SalesOrderLine, SuppressCommit, DropShptPostBuffer, TempPurchLineGlobal);    end;    local procedure GetSign(Value: Decimal): Integer    begin        if Value > 0 then            exit(1);        exit(-1);    end;    local procedure CheckICDocumentDuplicatePosting(PurchHeader: Record "Purchase Header")    var        PurchHeader2: Record "Purchase Header";        ICInboxPurchHeader: Record "IC Inbox Purchase Header";        PurchInvHeader2: Record "Purch. Inv. Header";        ConfirmManagement: Codeunit "Confirm Management";        IsHandled: Boolean;        ShouldCheckPosted: Boolean;        ShouldCheckUnposted: Boolean;    begin        IsHandled := false;        OnBeforeCheckICDocumentDuplicatePosting(PurchHeader, IsHandled);        if IsHandled then            exit;        if not PurchHeader.Invoice then            exit;        ShouldCheckPosted := PurchHeader."IC Direction" = PurchHeader."IC Direction"::Outgoing;        OnCheckICDocumentDuplicatePostingOnAfterCalcShouldCheckPosted(PurchHeader, ShouldCheckPosted);        if ShouldCheckPosted then begin            PurchInvHeader2.SetRange("Your Reference", PurchHeader."No.");            PurchInvHeader2.SetRange("Buy-from Vendor No.", PurchHeader."Buy-from Vendor No.");            PurchInvHeader2.SetRange("Pay-to Vendor No.", PurchHeader."Pay-to Vendor No.");            if PurchInvHeader2.FindFirst() then                if not ConfirmManagement.GetResponseOrDefault(                     StrSubstNo(PostedInvoiceDuplicateQst, PurchInvHeader2."No.", PurchHeader."No."), true)                then                    Error('');        end;        ShouldCheckUnposted := PurchHeader."IC Direction" = PurchHeader."IC Direction"::Incoming;        OnCheckICDocumentDuplicatePostingOnAfterCalcShouldCheckUnposted(PurchHeader, ShouldCheckUnposted);        if ShouldCheckUnposted then begin            if PurchHeader."Document Type" = PurchHeader."Document Type"::Order then begin                PurchHeader2.SetRange("Document Type", PurchHeader."Document Type"::Invoice);                PurchHeader2.SetRange("Vendor Order No.", PurchHeader."Vendor Order No.");                if PurchHeader2.FindFirst() then                    if not ConfirmManagement.GetResponseOrDefault(                         StrSubstNo(UnpostedInvoiceDuplicateQst, PurchHeader."No.", PurchHeader2."No."), true)                    then                        Error('');                ICInboxPurchHeader.SetRange("Document Type", PurchHeader."Document Type"::Invoice);                ICInboxPurchHeader.SetRange("Vendor Order No.", PurchHeader."Vendor Order No.");                if ICInboxPurchHeader.FindFirst() then                    if not ConfirmManagement.GetResponseOrDefault(                         StrSubstNo(InvoiceDuplicateInboxQst, PurchHeader."No.", ICInboxPurchHeader."No."), true)                    then                        Error('');                PurchInvHeader2.SetRange("Vendor Order No.", PurchHeader."Vendor Order No.");                if PurchInvHeader2.FindFirst() then                    if not ConfirmManagement.GetResponseOrDefault(                         StrSubstNo(PostedInvoiceDuplicateQst, PurchInvHeader2."No.", PurchHeader."No."), true)                    then                        Error('');            end;            if (PurchHeader."Document Type" = PurchHeader."Document Type"::Invoice) and (PurchHeader."Vendor Order No." <> '') then begin                PurchHeader2.SetRange("Document Type", PurchHeader."Document Type"::Order);                PurchHeader2.SetRange("Vendor Order No.", PurchHeader."Vendor Order No.");                if PurchHeader2.FindFirst() then                    if not ConfirmManagement.GetResponseOrDefault(                         StrSubstNo(OrderFromSameTransactionQst, PurchHeader2."No.", PurchHeader."No."), true)                    then                        Error('');                ICInboxPurchHeader.SetRange("Document Type", PurchHeader."Document Type"::Order);                ICInboxPurchHeader.SetRange("Vendor Order No.", PurchHeader."Vendor Order No.");                if ICInboxPurchHeader.FindFirst() then                    if not ConfirmManagement.GetResponseOrDefault(                         StrSubstNo(DocumentFromSameTransactionQst, PurchHeader."No.", ICInboxPurchHeader."No."), true)                    then                        Error('');                PurchInvHeader2.SetRange("Vendor Order No.", PurchHeader."Vendor Order No.");                if PurchInvHeader2.FindFirst() then                    if not ConfirmManagement.GetResponseOrDefault(                         StrSubstNo(PostedInvoiceFromSameTransactionQst, PurchInvHeader2."No.", PurchHeader."No."), true)                    then                        Error('');                if (PurchHeader."Your Reference" <> '') and (StrLen(PurchHeader."Your Reference") <= MaxStrLen(PurchInvHeader2."Order No.")) then begin                    PurchInvHeader2.Reset();                    PurchInvHeader2.SetRange("Order No.", PurchHeader."Your Reference");                    PurchInvHeader2.SetRange("Buy-from Vendor No.", PurchHeader."Buy-from Vendor No.");                    PurchInvHeader2.SetRange("Pay-to Vendor No.", PurchHeader."Pay-to Vendor No.");                    if PurchInvHeader2.FindFirst() then                        if not ConfirmManagement.GetResponseOrDefault(                             StrSubstNo(PostedInvoiceFromSameTransactionQst, PurchInvHeader2."No.", PurchHeader."No."), true)                        then                            Error('');                end;            end;        end;    end;    local procedure CheckICPartnerBlocked(PurchHeader: Record "Purchase Header")    var        ICPartner: Record "IC Partner";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckICPartnerBlocked(PurchHeader, IsHandled);        if IsHandled then            exit;        if PurchHeader."Buy-from IC Partner Code" <> '' then            if ICPartner.Get(PurchHeader."Buy-from IC Partner Code") then                ICPartner.TestField(Blocked, false);        if PurchHeader."Pay-to IC Partner Code" <> '' then            if ICPartner.Get(PurchHeader."Pay-to IC Partner Code") then                ICPartner.TestField(Blocked, false);    end;    local procedure SendICDocument(var PurchHeader: Record "Purchase Header"; var ModifyHeader: Boolean)    var        ICInboxOutboxMgt: Codeunit ICInboxOutboxMgt;        IsHandled: Boolean;    begin        OnBeforeSendICDocument(PurchHeader, ModifyHeader, IsHandled);        if IsHandled then            exit;        if PurchHeader."Send IC Document" and (PurchHeader."IC Status" = PurchHeader."IC Status"::New) and (PurchHeader."IC Direction" = PurchHeader."IC Direction"::Outgoing) and            (PurchHeader."Document Type" in [PurchHeader."Document Type"::Order, PurchHeader."Document Type"::"Return Order"])        then begin            ICInboxOutboxMgt.SendPurchDoc(PurchHeader, true);            PurchHeader."IC Status" := PurchHeader."IC Status"::Pending;            ModifyHeader := true;        end;    end;    local procedure UpdateHandledICInboxTransaction(PurchHeader: Record "Purchase Header")    var        HandledICInboxTrans: Record "Handled IC Inbox Trans.";        Vendor: Record Vendor;        IsHandled: Boolean;    begin        OnBeforeUpdateHandledICInboxTransaction(PurchHeader, IsHandled);        if IsHandled then            exit;        if PurchHeader."IC Direction" = PurchHeader."IC Direction"::Incoming then begin            case PurchHeader."Document Type" of                PurchHeader."Document Type"::Invoice:                    HandledICInboxTrans.SetRange("Document No.", PurchHeader."Vendor Invoice No.");                PurchHeader."Document Type"::Order:                    HandledICInboxTrans.SetRange("Document No.", PurchHeader."Vendor Order No.");                PurchHeader."Document Type"::"Credit Memo":                    HandledICInboxTrans.SetRange("Document No.", PurchHeader."Vendor Cr. Memo No.");                PurchHeader."Document Type"::"Return Order":                    HandledICInboxTrans.SetRange("Document No.", PurchHeader."Vendor Order No.");            end;            Vendor.Get(PurchHeader."Buy-from Vendor No.");            HandledICInboxTrans.SetRange("IC Partner Code", Vendor."IC Partner Code");            HandledICInboxTrans.LockTable();            if HandledICInboxTrans.FindFirst() then begin                HandledICInboxTrans.Status := HandledICInboxTrans.Status::Posted;                HandledICInboxTrans.Modify();            end;        end;    end;    local procedure MakeInventoryAdjustment()    var        InvtAdjmtHandler: Codeunit "Inventory Adjustment Handler";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeMakeInventoryAdjustment(IsHandled);        if IsHandled then            exit;        InvtAdjmtHandler.MakeAutomaticInventoryAdjustment(ItemsToAdjust);    end;    local procedure CheckTrackingAndWarehouseForReceive(PurchHeader: Record "Purchase Header") Receive: Boolean    var        TempPurchLine: Record "Purchase Line" temporary;    begin        ResetTempLines(TempPurchLine);        TempPurchLine.SetFilter(Quantity, '<>0');        if PurchHeader."Document Type" = PurchHeader."Document Type"::Order then            TempPurchLine.SetFilter("Qty. to Receive", '<>0');        TempPurchLine.SetRange("Receipt No.", '');        TempPurchLine.SetRange("Matched Order Lines", 0);        OnCheckTrackingAndWarehouseForReceiveOnAfterTempPurchLineSetFilters(PurchHeader, TempPurchLine);        Receive := TempPurchLine.FindFirst();        WhseReceive := TempWhseRcptHeader.FindFirst();        WhseShip := TempWhseShptHeader.FindFirst();        if Receive then begin            CheckTrackingSpecification(PurchHeader, TempPurchLine);            if not (WhseReceive or WhseShip or InvtPickPutaway) then                CheckWarehouse(TempPurchLine);        end;        OnAfterCheckTrackingAndWarehouseForReceive(            PurchHeader, Receive, SuppressCommit, TempWhseShptHeader, TempWhseRcptHeader, TempPurchLine);        exit(Receive);    end;    local procedure CheckTrackingAndWarehouseForShip(PurchHeader: Record "Purchase Header") Ship: Boolean    var        TempPurchLine: Record "Purchase Line" temporary;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckTrackingAndWarehouseForShip(PurchHeader, TempPurchLineGlobal, Ship, IsHandled);        if IsHandled then            exit(Ship);        ResetTempLines(TempPurchLine);        TempPurchLine.SetFilter(Quantity, '<>0');        TempPurchLine.SetFilter("Return Qty. to Ship", '<>0');        TempPurchLine.SetRange("Return Shipment No.", '');        OnCheckTrackingAndWarehouseForShipOnAfterTempPurchLineSetFilters(PurchHeader, TempPurchLine);        Ship := TempPurchLine.FindFirst();        WhseReceive := TempWhseRcptHeader.FindFirst();        WhseShip := TempWhseShptHeader.FindFirst();        if Ship then begin            CheckTrackingSpecification(PurchHeader, TempPurchLine);            if not (WhseShip or WhseReceive or InvtPickPutaway) then                CheckWarehouse(TempPurchLine);        end;        OnAfterCheckTrackingAndWarehouseForShip(PurchHeader, Ship, SuppressCommit, TempPurchLine, TempWhseShptHeader, TempWhseRcptHeader);        exit(Ship);    end;    local procedure CheckIfInvPutawayExists(PurchaseHeader: Record "Purchase Header"): Boolean    var        TempPurchLine: Record "Purchase Line" temporary;        WarehouseActivityLine: Record "Warehouse Activity Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckIfInvPutawayExists(PurchaseHeader, IsHandled);        if IsHandled then            exit;        ResetTempLines(TempPurchLine);        TempPurchLine.SetFilter(Quantity, '<>0');        if PurchaseHeader."Document Type" = PurchaseHeader."Document Type"::Order then            TempPurchLine.SetFilter("Qty. to Receive", '<>0');        TempPurchLine.SetRange("Receipt No.", '');        TempPurchLine.SetRange("Matched Order Lines", 0);        if TempPurchLine.IsEmpty() then            exit(false);        TempPurchLine.FindSet();        repeat            if WarehouseActivityLine.ActivityExists(                    DATABASE::"Purchase Line", TempPurchLine."Document Type".AsInteger(), TempPurchLine."Document No.", TempPurchLine."Line No.", 0,                    WarehouseActivityLine."Activity Type"::"Invt. Put-away".AsInteger())            then                exit(true);        until TempPurchLine.Next() = 0;        exit(false);    end;    local procedure CheckIfInvPickExists(): Boolean    var        TempPurchLine: Record "Purchase Line" temporary;        WarehouseActivityLine: Record "Warehouse Activity Line";    begin        ResetTempLines(TempPurchLine);        TempPurchLine.SetFilter(Quantity, '<>0');        TempPurchLine.SetFilter("Return Qty. to Ship", '<>0');        TempPurchLine.SetRange("Return Shipment No.", '');        if TempPurchLine.IsEmpty() then            exit(false);        TempPurchLine.FindSet();        repeat            if WarehouseActivityLine.ActivityExists(                    DATABASE::"Purchase Line", TempPurchLine."Document Type".AsInteger(), TempPurchLine."Document No.", TempPurchLine."Line No.", 0,                    WarehouseActivityLine."Activity Type"::"Invt. Pick".AsInteger())            then                exit(true);        until TempPurchLine.Next() = 0;        exit(false);    end;    local procedure CheckHeaderPostingType(var PurchHeader: Record "Purchase Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckHeaderPostingType(PurchHeader, IsHandled);        if IsHandled then            exit;        if not (PurchHeader.Receive or PurchHeader.Invoice or PurchHeader.Ship) then            Error(ErrorInfo.Create(DocumentErrorsMgt.GetNothingToPostErrorMsg(), true, PurchHeader));    end;    local procedure CheckAssociatedOrderLines(var PurchHeader: Record "Purchase Header")    var        PurchLine: Record "Purchase Line";        SalesHeader: Record "Sales Header";        SalesOrderLine: Record "Sales Line";        TempSalesHeader: Record "Sales Header" temporary;        TempSalesLine: Record "Sales Line" temporary;        CheckDimensions: Codeunit "Check Dimensions";        IsHandled: Boolean;    begin        OnBeforeCheckAssociatedOrderLines(PurchHeader);        PurchLine.Reset();        PurchLine.SetRange("Document Type", PurchHeader."Document Type");        PurchLine.SetRange("Document No.", PurchHeader."No.");        PurchLine.SetFilter("Sales Order Line No.", '<>0');        IsHandled := false;        OnCheckAssociatedOrderLinesOnAfterSetFilters(PurchLine, PurchHeader, IsHandled);        if IsHandled then            exit;        if PurchLine.FindSet() then            repeat                AddAssociatedOrderLineToBuffer(PurchHeader, PurchLine, SalesOrderLine, TempSalesLine);                if PurchHeader.Invoice then                    if Abs(PurchLine."Quantity Received" - PurchLine."Quantity Invoiced") < Abs(PurchLine."Qty. to Invoice") then begin                        PurchLine."Qty. to Invoice" := PurchLine."Quantity Received" - PurchLine."Quantity Invoiced";                        PurchLine."Qty. to Invoice (Base)" := PurchLine."Qty. Received (Base)" - PurchLine."Qty. Invoiced (Base)";                    end;                TempSalesHeader."Document Type" := TempSalesHeader."Document Type"::Order;                TempSalesHeader."No." := PurchLine."Sales Order No.";                if TempSalesHeader.Insert() then;            until PurchLine.Next() = 0;        if TempSalesHeader.FindSet() then            repeat                SalesHeader.Get(TempSalesHeader."Document Type"::Order, TempSalesHeader."No.");                TempSalesLine.SetRange("Document No.", SalesHeader."No.");                CheckDimensions.CheckSalesDim(SalesHeader, TempSalesLine);                OnCheckAssociatedOrderLinesOnAfterCheckDimensions(PurchHeader, SalesHeader, PurchLine, TempSalesLine);            until TempSalesHeader.Next() = 0;    end;    local procedure AddAssociatedOrderLineToBuffer(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeAddAssociatedOrderLineToBuffer(PurchHeader, PurchLine, SalesOrderLine, TempSalesLine, IsHandled);        if IsHandled then            exit;        SalesOrderLine.Get(            SalesOrderLine."Document Type"::Order, PurchLine."Sales Order No.", PurchLine."Sales Order Line No.");        TempSalesLine := SalesOrderLine;        TempSalesLine.Insert();    end;    local procedure RunItemJnlPostLine(var ItemJnlLineToPost: Record "Item Journal Line")    begin        ItemJnlPostLine.RunWithCheck(ItemJnlLineToPost);    end;    local procedure RunItemJnlPostLineWithReservation(var ItemJnlLineToPost: Record "Item Journal Line"; var ReservationEntry: Record "Reservation Entry")    begin        OnBeforeRunItemJnlPostLineWithReservation(ItemJnlLineToPost);        ItemJnlPostLine.RunPostWithReservation(ItemJnlLineToPost, ReservationEntry);    end;    local procedure PostCombineSalesOrderShipment(var PurchHeader: Record "Purchase Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    var        SalesSetup: Record "Sales & Receivables Setup";        SalesCommentLine: Record "Sales Comment Line";        SalesOrderHeader: Record "Sales Header";        SalesOrderLine: Record "Sales Line";        SalesShptLine: Record "Sales Shipment Line";        RecordLinkManagement: Codeunit "Record Link Management";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostCombineSalesOrderShipment(PurchHeader, TempDropShptPostBuffer, SalesShptHeader, ItemLedgShptEntryNo, ItemJnlPostLine, TempTrackingSpecification, TempHandlingSpecification, IsHandled);        if not IsHandled then begin            SalesSetup.Get();            ArchiveSalesOrders(TempDropShptPostBuffer);            if TempDropShptPostBuffer.FindSet() then                repeat                    SalesOrderHeader.Get(SalesOrderHeader."Document Type"::Order, TempDropShptPostBuffer."Order No.");                    OnPostCombineSalesOrderShipmentOnBeforeInsertSalesShptHeader(TempDropShptPostBuffer, SalesOrderHeader);                    InsertSalesShptHeader(SalesOrderHeader, PurchHeader, SalesShptHeader);                    ApprovalsMgmt.PostApprovalEntries(PurchHeader.RecordId, SalesShptHeader.RecordId, SalesShptHeader."No.");                    IsHandled := false;                    OnPostCombineSalesOrderShipmentOnBeforeCopyComments(PurchHeader, TempDropShptPostBuffer, SalesShptHeader, IsHandled);                    if not IsHandled then                        if SalesSetup."Copy Comments Order to Shpt." then begin                            SalesCommentLine.CopyComments(                              SalesOrderHeader."Document Type".AsInteger(), SalesCommentLine."Document Type"::Shipment.AsInteger(),                              SalesOrderHeader."No.", SalesShptHeader."No.");                            RecordLinkManagement.CopyLinks(SalesOrderHeader, SalesShptHeader);                        end;                    TempDropShptPostBuffer.SetRange("Order No.", TempDropShptPostBuffer."Order No.");                    repeat                        SalesOrderLine.Get(                          SalesOrderLine."Document Type"::Order,                          TempDropShptPostBuffer."Order No.", TempDropShptPostBuffer."Order Line No.");                        InsertSalesShptLine(SalesShptHeader, SalesOrderLine, TempDropShptPostBuffer, SalesShptLine);                        CheckSalesCertificateOfSupplyStatus(SalesShptHeader, SalesShptLine);                        SalesOrderLine."Qty. to Ship" := SalesShptLine.Quantity;                        SalesOrderLine."Qty. to Ship (Base)" := SalesShptLine."Quantity (Base)";                        OnPostCombineSalesOrderShipmentOnAfterUpdateSalesOrderLine(SalesShptHeader, SalesOrderHeader, SalesOrderLine, SalesShptLine);                        OnPostCombineSalesOrderShipmentOnBeforeUpdateBlanketOrderLine(SalesOrderLine, SalesShptLine);                        SalesPost.UpdateBlanketOrderLine(SalesOrderLine, true, false, false);                        OnPostCombineSalesOrderShipmentOnAfterUpdateBlanketOrderLine(PurchHeader, TempDropShptPostBuffer, SalesOrderLine, SalesOrderHeader, SalesShptLine, SalesShptHeader, SrcCode, Currency);                        SalesOrderLine.SetRange("Document Type", SalesOrderLine."Document Type"::Order);                        SalesOrderLine.SetRange("Document No.", TempDropShptPostBuffer."Order No.");                        SalesOrderLine.SetRange("Attached to Line No.", TempDropShptPostBuffer."Order Line No.");                        SalesOrderLine.SetRange(Type, SalesOrderLine.Type::" ");                        if SalesOrderLine.FindSet() then                            repeat                                SalesShptLine.Init();                                SalesShptLine.TransferFields(SalesOrderLine);                                SalesShptLine."Document No." := SalesShptHeader."No.";                                SalesShptLine."Order No." := SalesOrderLine."Document No.";                                SalesShptLine."Order Line No." := SalesOrderLine."Line No.";                                Clear(IsHandled);                                OnBeforeSalesShptLineInsert(SalesShptLine, SalesShptHeader, SalesOrderLine, SuppressCommit, TempDropShptPostBuffer, IsHandled);                                if not IsHandled then                                    SalesShptLine.Insert();                                OnAfterSalesShptLineInsert(SalesShptLine, SalesShptHeader, SalesOrderLine, SuppressCommit, TempDropShptPostBuffer, TempPurchLineGlobal);                            until SalesOrderLine.Next() = 0;                        OnPostCombineSalesOrderShipmentOnAfterProcessDropShptPostBuffer(TempDropShptPostBuffer, PurchRcptHeader, SalesShptLine, TempTrackingSpecification);                    until TempDropShptPostBuffer.Next() = 0;                    TempDropShptPostBuffer.SetRange("Order No.");                    OnAfterInsertCombinedSalesShipment(SalesShptHeader);                until TempDropShptPostBuffer.Next() = 0;        end;        OnAfterPostCombineSalesOrderShipment(PurchHeader, TempDropShptPostBuffer);    end;    local procedure FindTempItemChargeAssgntPurch(PurchLineNo: Integer): Boolean    begin        ClearItemChargeAssgntFilter();        TempItemChargeAssgntPurch.SetCurrentKey("Applies-to Doc. Type");        TempItemChargeAssgntPurch.SetRange("Document Line No.", PurchLineNo);        exit(TempItemChargeAssgntPurch.FindSet());    end;    local procedure CheckMandatoryHeaderFields(var PurchaseHeader: Record "Purchase Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckMandatoryFields(PurchaseHeader, IsHandled);        if not IsHandled then begin            PurchaseHeader.TestField("Document Type");            PurchaseHeader.TestField("Buy-from Vendor No.");            PurchaseHeader.TestField("Pay-to Vendor No.");            PurchaseHeader.TestField("Posting Date");            PurchaseHeader.TestField("Document Date");        end;        OnAfterCheckMandatoryFields(PurchaseHeader, SuppressCommit);    end;    local procedure ClearPostBuffers()    begin        Clear(WhsePostRcpt);        Clear(WhsePostShpt);        Clear(GenJnlPostLine);        Clear(JobPostLine);        Clear(ItemJnlPostLine);        Clear(WhseJnlPostLine);    end;    local procedure ValidatePostingAndDocumentDate(var PurchaseHeader: Record "Purchase Header")    var        BatchProcessingMgt: Codeunit "Batch Processing Mgt.";        PostingDate, VATDate : Date;        ModifyHeader: Boolean;        PostingDateExists: Boolean;        VATDateExists: Boolean;        ReplacePostingDate: Boolean;        ReplaceDocumentDate: Boolean;        ReplaceVATDate: Boolean;        IsHandled: Boolean;        SkipTestPostingDate: Boolean;    begin        OnBeforeValidatePostingAndDocumentDate(PurchaseHeader, SuppressCommit);        IsHandled := false;        OnValidatePostingAndDocumentDateOnSetPostingDateExists(PurchaseHeader, SuppressCommit, PostingDateExists, ReplacePostingDate, PostingDate, IsHandled);        if not IsHandled then            PostingDateExists :=                BatchProcessingMgt.GetBooleanParameter(                    PurchaseHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Replace Posting Date", ReplacePostingDate) and                BatchProcessingMgt.GetBooleanParameter(                    PurchaseHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Replace Document Date", ReplaceDocumentDate) and                BatchProcessingMgt.GetDateParameter(                    PurchaseHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Posting Date", PostingDate);        VATDateExists := BatchProcessingMgt.GetBooleanParameter(PurchaseHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Replace VAT Date", ReplaceVATDate);        BatchProcessingMgt.GetDateParameter(PurchaseHeader.RecordId, Enum::"Batch Posting Parameter Type"::"VAT Date", VATDate);        OnValidatePostingAndDocumentDateOnAfterCalcPostingDateExists(PurchaseHeader, PostingDateExists, ReplacePostingDate, PostingDate, ReplaceDocumentDate, ModifyHeader, VATDateExists, ReplaceVATDate, VATDate);        if PostingDateExists and (ReplacePostingDate or (PurchaseHeader."Posting Date" = 0D)) then begin            PurchaseHeader."Posting Date" := PostingDate;            PurchaseHeader.Validate("Currency Code");            ModifyHeader := true;        end;        IsHandled := false;        OnValidatePostingAndDocumentDateOnBeforeSetReplaceDocumentDate(PurchaseHeader, PostingDate, ReplaceDocumentDate, ModifyHeader, IsHandled);        if not IsHandled then            if PostingDateExists and ReplaceDocumentDate and (PurchaseHeader."Document Date" <> PostingDate) then begin                PurchaseHeader.SetReplaceDocumentDate();                PurchaseHeader.Validate("Document Date", PostingDate);                ModifyHeader := true;            end;        if VATDateExists and (ReplaceVATDate) then begin            PurchaseHeader."VAT Reporting Date" := VATDate;            ModifyHeader := true;        end;        if not ReplacePostingDate then begin            SkipTestPostingDate := false;            OnValidatePostingAndDocumentDateOnBeforeTestPostingDate(PurchaseHeader, PostingDateExists, SkipTestPostingDate);            if not SkipTestPostingDate then                PurchaseHeader.TestPostingDate(PostingDateExists);        end;        OnValidatePostingAndDocumentDateOnBeforePurchaseHeaderModify(PurchaseHeader, ModifyHeader);        if ModifyHeader then            PurchaseHeader.Modify();        OnAfterValidatePostingAndDocumentDate(PurchaseHeader, SuppressCommit, PreviewMode);    end;    local procedure CheckExternalDocumentNumber(var VendLedgEntry: Record "Vendor Ledger Entry"; var PurchaseHeader: Record "Purchase Header")    var        VendorMgt: Codeunit "Vendor Mgt.";        Handled: Boolean;    begin        OnBeforeCheckExternalDocumentNumber(VendLedgEntry, PurchaseHeader, Handled, GenJnlLineDocType.AsInteger(), GenJnlLineExtDocNo, SrcCode, GenJnlLineDocType, GenJnlLineDocNo, GenJnlPostLine, TotalPurchLine, TotalPurchLineLCY);        if Handled then            exit;        VendLedgEntry.Reset();        VendLedgEntry.SetCurrentKey("External Document No.");        VendorMgt.SetFilterForExternalDocNo(            VendLedgEntry, GenJnlLineDocType, GenJnlLineExtDocNo, PurchaseHeader."Pay-to Vendor No.", PurchaseHeader."Document Date");        OnCheckExternalDocumentNumberOnAfterSetFilters(VendLedgEntry, PurchaseHeader);        if VendLedgEntry.FindFirst() then            Error(              PurchaseAlreadyExistsErr, VendLedgEntry."Document Type", GenJnlLineExtDocNo);    end;    local procedure PostItemTracking(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; TrackingSpecificationExists: Boolean)    var        QtyToInvoiceBaseInTrackingSpec: Decimal;        IsHandled: Boolean;        ShouldProcessShipment: Boolean;    begin        IsHandled := false;        OnBeforePostItemTracking(            PurchHeader, PurchLine, TempTrackingSpecification, TrackingSpecificationExists,            PreciseTotalChargeAmt, PreciseTotalChargeAmtACY, RoundedPrevTotalChargeAmt, RoundedPrevTotalChargeAmtACY, IsHandled, RemQtyToBeInvoiced);        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;        ShouldProcessShipment := PurchHeader.IsCreditDocType();        OnPostItemTrackingOnAfterCalcShouldProcessShipment(PurchHeader, PurchLine, ShouldProcessShipment);        if ShouldProcessShipment then begin            if (Abs(RemQtyToBeInvoiced) > Abs(PurchLine."Return Qty. to Ship")) or               (Abs(RemQtyToBeInvoiced) >= Abs(QtyToInvoiceBaseInTrackingSpec)) and (QtyToInvoiceBaseInTrackingSpec <> 0)            then                PostItemTrackingForShipment(PurchHeader, PurchLine, TrackingSpecificationExists, TempTrackingSpecification);            PostItemTrackingCheckShipment(PurchLine, RemQtyToBeInvoiced);        end else begin            if (Abs(RemQtyToBeInvoiced) > Abs(PurchLine."Qty. to Receive")) or               (Abs(RemQtyToBeInvoiced) >= Abs(QtyToInvoiceBaseInTrackingSpec)) and (QtyToInvoiceBaseInTrackingSpec <> 0)            then                PostItemTrackingForReceipt(PurchHeader, PurchLine, TrackingSpecificationExists, TempTrackingSpecification);            PostItemTrackingCheckReceipt(PurchLine, RemQtyToBeInvoiced);        end;    end;    local procedure PostItemTrackingCheckShipment(PurchaseLine: Record "Purchase Line"; RemQtyToBeInvoiced: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemTrackingCheckShipment(PurchaseLine, RemQtyToBeInvoiced, IsHandled);        if IsHandled then            exit;        if Abs(RemQtyToBeInvoiced) > Abs(PurchaseLine."Return Qty. to Ship") then begin            if PurchaseLine."Document Type" = PurchaseLine."Document Type"::"Credit Memo" then                Error(InvoiceGreaterThanReturnShipmentErr, ReturnShptHeader."No.");            Error(ReturnShipmentLinesDeletedErr);        end;    end;    procedure PostItemTrackingCheckReceipt(PurchaseLine: Record "Purchase Line"; RemQtyToBeInvoiced: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemTrackingCheckReceipt(PurchaseLine, RemQtyToBeInvoiced, IsHandled);        if IsHandled then            exit;        if Abs(RemQtyToBeInvoiced) > Abs(PurchaseLine."Qty. to Receive") then begin            if PurchaseLine."Document Type" = PurchaseLine."Document Type"::Invoice then                Error(QuantityToInvoiceGreaterErr, PurchRcptHeader."No.");            Error(ReceiptLinesDeletedErr);        end;    end;    procedure PostItemTrackingForReceipt(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary)    var        PurchRcptLine: Record "Purch. Rcpt. Line";        ItemEntryRelation: Record "Item Entry Relation";        EndLoop: Boolean;        RemQtyToInvoiceCurrLine: Decimal;        RemQtyToInvoiceCurrLineBase: Decimal;        QtyToBeInvoiced: Decimal;        QtyToBeInvoicedBase: Decimal;        IsHandled: Boolean;    begin        EndLoop := false;        PurchRcptLine.Reset();        case PurchHeader."Document Type" of            PurchHeader."Document Type"::Order:                begin                    PurchRcptLine.SetCurrentKey("Order No.", "Order Line No.");                    PurchRcptLine.SetRange("Order No.", PurchLine."Document No.");                    PurchRcptLine.SetRange("Order Line No.", PurchLine."Line No.");                end;            PurchHeader."Document Type"::Invoice:                if MatchedOrderLineMgmt.IsLineMatchedToReceiptShipment(PurchLine) then                    MatchedOrderLineMgmt.SetMatchedReceiptLinesFilter(PurchRcptLine, PurchLine)                else begin                    PurchRcptLine.SetRange("Document No.", PurchLine."Receipt No.");                    PurchRcptLine.SetRange("Line No.", PurchLine."Receipt Line No.");                end;        end;        PurchRcptLine.SetFilter("Qty. Rcd. Not Invoiced", '<>0');        OnPostItemTrackingForReceiptOnAfterPurchRcptLineSetFilters(PurchRcptLine, PurchLine, PurchHeader);        if PurchRcptLine.FindSet(true) then begin            ItemJnlRollRndg := true;            repeat                GetPurchRcptLineFromTrackingOrUpdateItemEntryRelation(PurchRcptLine, TrackingSpecificationExists, ItemEntryRelation, TempTrackingSpecification);                UpdateRemainingQtyToBeInvoiced(RemQtyToInvoiceCurrLine, RemQtyToInvoiceCurrLineBase, PurchRcptLine);                UpdateChargeItemPurchaseRcptLineGenProdPostingGroup(PurchRcptLine);                CheckPurchRcptLine(PurchRcptLine, PurchLine);                OnPostItemTrackingForReceiptOnAfterPurchRcptLineTestFields(PurchRcptLine, PurchLine);                UpdateReceiptInvoicingQuantities(                    QtyToBeInvoiced,                    QtyToBeInvoicedBase,                    TrackingSpecificationExists,                    PurchLine,                    PurchRcptLine,                    TempTrackingSpecification,                    RemQtyToInvoiceCurrLine,                    RemQtyToInvoiceCurrLineBase);                UpdateInvoicedQtyOnPurchRcptLine(                  PurchInvHeader, PurchRcptLine, PurchHeader, PurchLine, QtyToBeInvoiced, QtyToBeInvoicedBase, TrackingSpecificationExists, TempTrackingSpecification);                OnPostItemTrackingForReceiptOnBeforePostItemTrackingForReceiptCondition(PurchInvHeader, PurchRcptLine, QtyToBeInvoiced, QtyToBeInvoicedBase);                if PostItemTrackingForReceiptCondition(PurchLine, PurchRcptLine) then                    PostItemJnlLine(                      PurchHeader, PurchLine, 0, 0, QtyToBeInvoiced, QtyToBeInvoicedBase,                      ItemEntryRelation."Item Entry No.", '', TempTrackingSpecification);                EndLoop :=                    IsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced, TrackingSpecificationExists, PurchRcptLine, TempTrackingSpecification, PurchLine);            until EndLoop;        end else begin            IsHandled := false;            OnPostItemTrackingForReceiptOnBeforeReceiptInvoiceErr(PurchLine, IsHandled);            if not IsHandled then                Error(ReceiptInvoicedErr, PurchLine."Receipt Line No.", PurchLine."Receipt No.");        end;    end;    local procedure IsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var PurchRcptLine: Record "Purch. Rcpt. Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; PurchLine: Record "Purchase Line") EndLoop: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeIsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced, TrackingSpecificationExists, PurchRcptLine, InvoicingTrackingSpecification, PurchLine, EndLoop, IsHandled);        if IsHandled then            exit;        if TrackingSpecificationExists then            exit((InvoicingTrackingSpecification.Next() = 0) or (RemQtyToBeInvoiced = 0));        exit((PurchRcptLine.Next() = 0) or (Abs(RemQtyToBeInvoiced) <= Abs(PurchLine."Qty. to Receive")));    end;    local procedure AdjustQuantityRoundingForReceipt(PurchRcptLine: Record "Purch. Rcpt. Line"; RemQtyToInvoiceCurrLine: Decimal; var QtyToBeInvoiced: Decimal; RemQtyToInvoiceCurrLineBase: Decimal; QtyToBeInvoicedBase: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeAdjustQuantityRoundingForReceipt(PurchRcptLine, RemQtyToInvoiceCurrLine, QtyToBeInvoiced, RemQtyToInvoiceCurrLineBase, QtyToBeInvoicedBase, IsHandled);        if IsHandled then            exit;        ItemTrackingMgt.AdjustQuantityRounding(RemQtyToInvoiceCurrLine, QtyToBeInvoiced, RemQtyToInvoiceCurrLineBase, QtyToBeInvoicedBase);    end;    local procedure GetPurchRcptLineFromTrackingOrUpdateItemEntryRelation(var PurchRcptLine: Record "Purch. Rcpt. Line"; TrackingSpecificationExists: Boolean; var ItemEntryRelation: Record "Item Entry Relation"; var TempTrackingSpecification: Record "Tracking Specification" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetPurchRcptLineFromTrackingOrUpdateItemEntryRelation(PurchRcptLine, TempTrackingSpecification, ItemEntryRelation, IsHandled);        if IsHandled then            exit;        if TrackingSpecificationExists then begin            ItemEntryRelation.Get(TempTrackingSpecification."Item Ledger Entry No.");            PurchRcptLine.Get(ItemEntryRelation."Source ID", ItemEntryRelation."Source Ref. No.");        end else            ItemEntryRelation."Item Entry No." := PurchRcptLine."Item Rcpt. Entry No.";    end;    local procedure CheckPurchRcptLine(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchLine: Record "Purchase Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckPurchRcptLine(PurchRcptLine, PurchLine, IsHandled);        if IsHandled then            exit;        PurchRcptLine.TestField("Buy-from Vendor No.", PurchLine."Buy-from Vendor No.");        PurchRcptLine.TestField(Type, PurchLine.Type);        PurchRcptLine.TestField("No.", PurchLine."No.");        PurchRcptLine.TestField("Gen. Bus. Posting Group", PurchLine."Gen. Bus. Posting Group");        PurchRcptLine.TestField("Gen. Prod. Posting Group", PurchLine."Gen. Prod. Posting Group");        PurchRcptLine.TestField("Job No.", PurchLine."Job No.");        PurchRcptLine.TestField("Unit of Measure Code", PurchLine."Unit of Measure Code");        PurchRcptLine.TestField("Variant Code", PurchLine."Variant Code");        OnAfterCheckPurchRcptLine(PurchRcptLine, PurchLine);    end;    local procedure PostItemTrackingForReceiptCondition(PurchLine: Record "Purchase Line"; PurchRcptLine: Record "Purch. Rcpt. Line"): Boolean    var        Condition: Boolean;    begin        Condition := PurchLine.Type = PurchLine.Type::Item;        OnBeforePostItemTrackingForReceiptCondition(PurchLine, PurchRcptLine, Condition);        exit(Condition);    end;    local procedure PostItemTrackingForShipment(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary)    var        ReturnShptLine: Record "Return Shipment Line";        ItemEntryRelation: Record "Item Entry Relation";        EndLoop: Boolean;        QtyToBeInvoiced: Decimal;        QtyToBeInvoicedBase: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItemTrackingForShipment(PurchHeader, PurchLine, IsHandled);        if IsHandled then            exit;        EndLoop := false;        ReturnShptLine.Reset();        OnPostItemTrackingForShipmentOnAfterReturnShptLineReset(ReturnShptLine, PurchHeader, PurchLine);        case PurchHeader."Document Type" of            PurchHeader."Document Type"::"Return Order":                begin                    ReturnShptLine.SetCurrentKey("Return Order No.", "Return Order Line No.");                    ReturnShptLine.SetRange("Return Order No.", PurchLine."Document No.");                    ReturnShptLine.SetRange("Return Order Line No.", PurchLine."Line No.");                end;            PurchHeader."Document Type"::"Credit Memo":                begin                    ReturnShptLine.SetRange("Document No.", PurchLine."Return Shipment No.");                    ReturnShptLine.SetRange("Line No.", PurchLine."Return Shipment Line No.");                end;        end;        ReturnShptLine.SetFilter("Return Qty. Shipped Not Invd.", '<>0');        if ReturnShptLine.FindSet(true) then begin            ItemJnlRollRndg := true;            repeat                IsHandled := false;                OnPostItemTrackingForShipmentOnBeforeSetItemEntryRelationForShipment(ItemEntryRelation, ReturnShptLine, TempTrackingSpecification, IsHandled);                if not IsHandled then                    if TrackingSpecificationExists then begin // Item Tracking                        ItemEntryRelation.Get(TempTrackingSpecification."Item Ledger Entry No.");                        ReturnShptLine.Get(ItemEntryRelation."Source ID", ItemEntryRelation."Source Ref. No.");                    end else                        ItemEntryRelation."Item Entry No." := ReturnShptLine."Item Shpt. Entry No.";                UpdateChargeItemReturnShptLineGenProdPostingGroup(ReturnShptLine);                CheckFieldsOnReturnShipmentLine(ReturnShptLine, PurchLine);                UpdateQtyToBeInvoicedForReturnShipment(                  QtyToBeInvoiced, QtyToBeInvoicedBase,                  TrackingSpecificationExists, PurchLine, ReturnShptLine, TempTrackingSpecification);                if TrackingSpecificationExists then begin                    TempTrackingSpecification."Quantity actual Handled (Base)" := QtyToBeInvoicedBase;                    TempTrackingSpecification.Modify();                end;                IsHandled := false;                OnPostItemTrackingForShipmentOnBeforeAdjustQuantityRounding(ReturnShptLine, RemQtyToBeInvoiced, QtyToBeInvoiced, RemQtyToBeInvoicedBase, QtyToBeInvoicedBase, IsHandled);                if not IsHandled then                    if TrackingSpecificationExists then                        ItemTrackingMgt.AdjustQuantityRounding(                          RemQtyToBeInvoiced, QtyToBeInvoiced, RemQtyToBeInvoicedBase, QtyToBeInvoicedBase);                RemQtyToBeInvoiced := RemQtyToBeInvoiced - QtyToBeInvoiced;                RemQtyToBeInvoicedBase := RemQtyToBeInvoicedBase - QtyToBeInvoicedBase;                UpdateInvoicedQtyOnReturnShptLine(ReturnShptLine, QtyToBeInvoiced, QtyToBeInvoicedBase);                OnAfterUpdateInvoicedQtyOnReturnShptLine(                  PurchCrMemoHeader, ReturnShptLine, PurchLine, TempTrackingSpecification, TrackingSpecificationExists,                  QtyToBeInvoiced, QtyToBeInvoicedBase);                if PostItemTrackingForShipmentCondition(PurchLine, ReturnShptLine) then                    PostItemJnlLine(                      PurchHeader, PurchLine, 0, 0, QtyToBeInvoiced, QtyToBeInvoicedBase,                      ItemEntryRelation."Item Entry No.", '', TempTrackingSpecification);                EndLoop :=                    IsEndLoopForShippedNotInvoiced(RemQtyToBeInvoiced, TrackingSpecificationExists, ReturnShptLine, TempTrackingSpecification, PurchLine);            until EndLoop;        end else begin            IsHandled := false;            OnPostItemTrackingForShipmentOnBeforeReturnShipmentInvoiceErr(PurchLine, IsHandled);            if not IsHandled then                Error(ReturnShipmentInvoicedErr, PurchLine."Return Shipment Line No.", PurchLine."Return Shipment No.");        end;    end;    local procedure IsEndLoopForShippedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var ReturnShptLine: Record "Return Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; PurchLine: Record "Purchase Line") EndLoop: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeIsEndLoopForShippedNotInvoiced(RemQtyToBeInvoiced, TrackingSpecificationExists, ReturnShptLine, InvoicingTrackingSpecification, PurchLine, EndLoop, IsHandled);        if IsHandled then            exit;        if TrackingSpecificationExists then            exit((InvoicingTrackingSpecification.Next() = 0) or (RemQtyToBeInvoiced = 0));        exit((ReturnShptLine.Next() = 0) or (Abs(RemQtyToBeInvoiced) <= Abs(PurchLine."Return Qty. to Ship")));    end;    local procedure CheckFieldsOnReturnShipmentLine(var ReturnShipmentLine: Record "Return Shipment Line"; PurchaseLine: Record "Purchase Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckFieldsOnReturnShipmentLine(ReturnShipmentLine, PurchaseLine, IsHandled);        if IsHandled then            exit;        ReturnShipmentLine.TestField("Buy-from Vendor No.", PurchaseLine."Buy-from Vendor No.");        ReturnShipmentLine.TestField(Type, PurchaseLine.Type);        ReturnShipmentLine.TestField("No.", PurchaseLine."No.");        ReturnShipmentLine.TestField("Gen. Bus. Posting Group", PurchaseLine."Gen. Bus. Posting Group");        ReturnShipmentLine.TestField("Gen. Prod. Posting Group", PurchaseLine."Gen. Prod. Posting Group");        ReturnShipmentLine.TestField("Job No.", PurchaseLine."Job No.");        ReturnShipmentLine.TestField("Unit of Measure Code", PurchaseLine."Unit of Measure Code");        ReturnShipmentLine.TestField("Variant Code", PurchaseLine."Variant Code");        OnAfterCheckFieldsOnReturnShipmentLine(ReturnShipmentLine, PurchaseLine);    end;    local procedure PostItemTrackingForShipmentCondition(PurchLine: Record "Purchase Line"; ReturnShipmentLine: Record "Return Shipment Line"): Boolean    var        Condition: Boolean;    begin        Condition := PurchLine.Type = PurchLine.Type::Item;        OnBeforePostItemTrackingForShipmentCondition(PurchLine, ReturnShipmentLine, Condition);        exit(Condition);    end;    local procedure PostUpdateOrderLine(PurchHeader: Record "Purchase Header")    var        TempPurchLine: Record "Purchase Line" temporary;        OverReceiptMgt: Codeunit "Over-Receipt Mgt.";        SetDefaultQtyBlank: Boolean;    begin        OnBeforePostUpdateOrderLine(PurchHeader, TempPurchLineGlobal, SuppressCommit, PurchSetup);        ResetTempLines(TempPurchLine);        TempPurchLine.SetRange("Prepayment Line", false);        TempPurchLine.SetFilter(Quantity, '<>0');        OnPostUpdateOrderLineOnBeforeFindTempPurchLine(TempPurchLine, PurchHeader);        if TempPurchLine.FindSet() then            repeat                OnPostUpdateOrderLineOnBeforeLoop(PurchHeader, TempPurchLine);                if PurchHeader.Receive then begin                    TempPurchLine."Quantity Received" += TempPurchLine."Qty. to Receive";                    TempPurchLine."Qty. Received (Base)" += TempPurchLine."Qty. to Receive (Base)";                    if not OverReceiptMgt.IsOverReceiptPendingOnWarehouseReceiptLine(TempPurchLine) then                        TempPurchLine."Over-Receipt Quantity" := 0;                    OnPostUpdateOrderLineOnPurchHeaderReceive(TempPurchLine, PurchRcptHeader);                end;                OnPostUpdateOrderLineOnAfterReceive(PurchHeader, TempPurchLine);                if PurchHeader.Ship then begin                    TempPurchLine."Return Qty. Shipped" += TempPurchLine."Return Qty. to Ship";                    TempPurchLine."Return Qty. Shipped (Base)" += TempPurchLine."Return Qty. to Ship (Base)";                end;                if PurchHeader.Invoice then begin                    if TempPurchLine."Document Type" = TempPurchLine."Document Type"::Order then                        UpdateQtyToInvoiceForOrder(PurchHeader, TempPurchLine)                    else                        UpdateQtyToInvoiceForReturnOrder(PurchHeader, TempPurchLine);                    TempPurchLine."Quantity Invoiced" := TempPurchLine."Quantity Invoiced" + TempPurchLine."Qty. to Invoice";                    TempPurchLine."Qty. Invoiced (Base)" := TempPurchLine."Qty. Invoiced (Base)" + TempPurchLine."Qty. to Invoice (Base)";                    if TempPurchLine."Qty. to Invoice" <> 0 then begin                        TempPurchLine."Prepmt Amt Deducted" += TempPurchLine."Prepmt Amt to Deduct";                        TempPurchLine."Prepmt VAT Diff. Deducted" += TempPurchLine."Prepmt VAT Diff. to Deduct";                        DecrementPrepmtAmtInvLCY(                          PurchHeader, TempPurchLine, TempPurchLine."Prepmt. Amount Inv. (LCY)", TempPurchLine."Prepmt. VAT Amount Inv. (LCY)");                        TempPurchLine."Prepmt Amt to Deduct" := TempPurchLine."Prepmt. Amt. Inv." - TempPurchLine."Prepmt Amt Deducted";                        TempPurchLine."Prepmt VAT Diff. to Deduct" := 0;                    end;                end;                OnPostUpdateOrderLineOnBeforeUpdateBlanketOrderLine(PurchHeader, TempPurchLine);                UpdateBlanketOrderLine(TempPurchLine, PurchHeader.Receive, PurchHeader.Ship, PurchHeader.Invoice);                OnPostUpdateOrderLineOnBeforeInitOutstanding(PurchHeader, TempPurchLine);                TempPurchLine.InitOutstanding();                SetDefaultQtyBlank := PurchSetup."Default Qty. to Receive" = PurchSetup."Default Qty. to Receive"::Blank;                OnPostUpdateOrderLineOnSetDefaultQtyBlank(PurchHeader, TempPurchLine, PurchSetup, SetDefaultQtyBlank);                if WhseHandlingRequiredExternal(TempPurchLine) or SetDefaultQtyBlank then begin                    if TempPurchLine."Document Type" = TempPurchLine."Document Type"::"Return Order" then begin                        TempPurchLine."Return Qty. to Ship" := 0;                        TempPurchLine."Return Qty. to Ship (Base)" := 0;                    end else begin                        TempPurchLine."Qty. to Receive" := 0;                        TempPurchLine."Qty. to Receive (Base)" := 0;                    end;                    OnPostUpdateOrderLineOnBeforeInitQtyToInvoice(TempPurchLine, WhseShip, WhseReceive);                    TempPurchLine.InitQtyToInvoice();                end else begin                    if TempPurchLine."Document Type" = TempPurchLine."Document Type"::"Return Order" then                        TempPurchLine.InitQtyToShip()                    else                        TempPurchLine.InitQtyToReceive2();                    OnPostUpdateOrderLineOnAfterInitQtyToReceiveOrShip(PurchHeader, TempPurchLine);                end;                TempPurchLine.SetDefaultQuantity();                OnBeforePostUpdateOrderLineModifyTempLine(TempPurchLine, WhseShip, WhseReceive, SuppressCommit, PurchHeader);                ModifyTempLine(TempPurchLine);                OnAfterPostUpdateOrderLine(TempPurchLine, WhseShip, WhseReceive, SuppressCommit);            until TempPurchLine.Next() = 0;    end;    local procedure UpdateQtyToInvoiceForOrder(PurchHeader: Record "Purchase Header"; var TempPurchLine: Record "Purchase Line" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateQtyToInvoiceForOrder(PurchHeader, TempPurchLine, IsHandled);        if IsHandled then            exit;        if Abs(TempPurchLine."Quantity Invoiced" + TempPurchLine."Qty. to Invoice") > Abs(TempPurchLine."Quantity Received") then begin            TempPurchLine.Validate("Qty. to Invoice", TempPurchLine."Quantity Received" - TempPurchLine."Quantity Invoiced");            TempPurchLine."Qty. to Invoice (Base)" := TempPurchLine."Qty. Received (Base)" - TempPurchLine."Qty. Invoiced (Base)";        end;    end;    local procedure UpdateQtyToInvoiceForReturnOrder(PurchHeader: Record "Purchase Header"; var TempPurchLine: Record "Purchase Line" temporary)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateQtyToInvoiceForReturnOrder(PurchHeader, TempPurchLine, IsHandled);        if IsHandled then            exit;        if Abs(TempPurchLine."Quantity Invoiced" + TempPurchLine."Qty. to Invoice") > Abs(TempPurchLine."Return Qty. Shipped") then begin            TempPurchLine.Validate("Qty. to Invoice", TempPurchLine."Return Qty. Shipped" - TempPurchLine."Quantity Invoiced");            TempPurchLine."Qty. to Invoice (Base)" := TempPurchLine."Return Qty. Shipped (Base)" - TempPurchLine."Qty. Invoiced (Base)";        end;    end;    /// <summary>    /// Update the purchase lines that have a non-blank type and receipt created against them    /// </summary>    /// <remarks>    /// Purchase receipt line must exist for purchase document    /// Purchase order line must exist for purchase document    /// For purchase line of type "Charge (Item)" entries Item Charge Assignment (Purch) are created/updated    /// If purchase line is associated with sales order line check if perfomed that invoiced quantity on sales does not exeed invoiced quantity on purhcase. If it's exeeded, an error is raised    /// If purchase order line has prepayments, prepayment amounts and VAT is updated    /// Outstanding quantities on the purchase order line are updated    /// </remarks>    /// <param name="PurchaseHeader">The purchase header of the document that is being posted.</param>    procedure PostUpdateInvoiceLine(var PurchaseHeader: Record "Purchase Header")    var        PurchOrderLine: Record "Purchase Line";        PurchRcptLine: Record "Purch. Rcpt. Line";        TempPurchLine: Record "Purchase Line" temporary;        IsHandled: Boolean;    begin        ResetTempLines(TempPurchLine);        IsHandled := false;        OnBeforePostUpdateInvoiceLine(TempPurchLine, IsHandled, PurchaseHeader);        if IsHandled then            exit;        MatchedOrderLineMgmt.UpdateMatchedOrderLines(TempPurchLine, PurchaseHeader);        TempPurchLine.SetFilter("Receipt No.", '<>%1', '');        TempPurchLine.SetFilter(Type, '<>%1', TempPurchLine.Type::" ");        if TempPurchLine.FindSet() then            repeat                PurchRcptLine.Get(TempPurchLine."Receipt No.", TempPurchLine."Receipt Line No.");                PurchOrderLine.Get(                  PurchOrderLine."Document Type"::Order,                  PurchRcptLine."Order No.", PurchRcptLine."Order Line No.");                OnPostUpdateInvoiceLineOnAfterPurchOrderLineGet(TempPurchLine, PurchRcptLine, PurchOrderLine);                if TempPurchLine.Type = TempPurchLine.Type::"Charge (Item)" then                    UpdatePurchOrderChargeAssgnt(TempPurchLine, PurchOrderLine);                IsHandled := false;                OnPostUpdateInvoiceLineOnBeforeCalcQty(TempPurchLine, PurchOrderLine, IsHandled);                if not IsHandled then begin                    PurchOrderLine."Quantity Invoiced" += TempPurchLine."Qty. to Invoice";                    PurchOrderLine."Qty. Invoiced (Base)" += TempPurchLine."Qty. to Invoice (Base)";                    if Abs(PurchOrderLine."Quantity Invoiced") > Abs(PurchOrderLine."Quantity Received") then                        Error(InvoiceMoreThanReceivedErr, PurchOrderLine."Document No.");                end;                OnPostUpdateInvoiceLineOnBeforeInitQtyToInvoice(PurchOrderLine, TempPurchLine);                PurchOrderLine.InitQtyToInvoice();                if PurchOrderLine."Prepayment %" <> 0 then begin                    PurchOrderLine."Prepmt Amt Deducted" += TempPurchLine."Prepmt Amt to Deduct";                    PurchOrderLine."Prepmt VAT Diff. Deducted" += TempPurchLine."Prepmt VAT Diff. to Deduct";                    DecrementPrepmtAmtInvLCY(                      PurchaseHeader, TempPurchLine, PurchOrderLine."Prepmt. Amount Inv. (LCY)", PurchOrderLine."Prepmt. VAT Amount Inv. (LCY)");                    PurchOrderLine."Prepmt Amt to Deduct" :=                      PurchOrderLine."Prepmt. Amt. Inv." - PurchOrderLine."Prepmt Amt Deducted";                    PurchOrderLine."Prepmt VAT Diff. to Deduct" := 0;                end;                PurchOrderLine.InitOutstanding();                OnPostUpdateInvoiceLineOnBeforePurchOrderLineModify(PurchOrderLine);                PurchOrderLine.Modify();                OnPostUpdateInvoiceLineOnAfterPurchOrderLineModify(PurchOrderLine, TempPurchLine, PurchOrderLine, TempPurchLine);            until TempPurchLine.Next() = 0;        OnAfterPostUpdateInvoiceLine(TempPurchLine);    end;    local procedure PostUpdateOrderNo(var PurchInvHeader: Record "Purch. Inv. Header")    var        PurchInvLine: Record "Purch. Inv. Line";        OrderNo: Code[20];    begin        if PurchInvHeader."No." = '' then            exit;        // Do not change 'Order No.' if already set         if PurchInvHeader."Order No." <> '' then            exit;        // Get a line where 'Order No.' is set        PurchInvLine.SetLoadFields("Order No.");        PurchInvLine.SetRange("Document No.", PurchInvHeader."No.");        PurchInvLine.SetFilter(Type, '<>%1', PurchInvLine.Type::" "); // Ignore comment lines        PurchInvLine.SetFilter("Order No.", '<>%1', '');        if not PurchInvLine.FindFirst() then            exit;        OrderNo := PurchInvLine."Order No.";        // If all the lines have the same 'Order No.' then set 'Order No.' field on the header        PurchInvLine.SetFilter("Order No.", '<>%1', OrderNo);        if PurchInvLine.FindSet() then            repeat                if not IsInvoiceRoundingLine(PurchInvHeader."Vendor Posting Group", PurchInvLine) then                    exit;            until PurchInvLine.Next() = 0;        PurchInvHeader.Validate("Order No.", OrderNo);        PurchInvHeader.Modify(true);    end;    local procedure IsInvoiceRoundingLine(VendorPostingGroupCode: Code[20]; PurchInvLine: Record "Purch. Inv. Line"): Boolean    var        VendorPostingGroup: Record "Vendor Posting Group";    begin        if (PurchInvLine."Order No." <> '') or           (PurchInvLine.Type <> PurchInvLine.Type::"G/L Account") or           not PurchInvLine."System-Created Entry"        then            exit(false);        VendorPostingGroup.Get(VendorPostingGroupCode);        exit(PurchInvLine."No." = VendorPostingGroup."Invoice Rounding Account");    end;    /// <summary>    /// Update the purchase lines that have a non-blank type and return shipment created against them    /// </summary>    /// <remarks>    /// Return shipment line must exist for purchase document    /// Purchase return order line must exist for purchase document    /// For purchase line of type "Charge (Item)" entries Item Charge Assignment (Purch) are created/updated    /// When trying to invoice more than has been returned an error is raised    /// Outstanding quantities on the purchase order line are updated    /// </remarks>    /// <param name="PurchaseHeader">The purchase header of the document that is being posted.</param>    procedure PostUpdateCreditMemoLine(var PurchaseHeader: Record "Purchase Header")    var        PurchOrderLine: Record "Purchase Line";        ReturnShptLine: Record "Return Shipment Line";        TempPurchLine: Record "Purchase Line" temporary;        IsHandled: Boolean;    begin        ResetTempLines(TempPurchLine);        IsHandled := false;        OnPostUpdateCreditMemoLineOnAfterResetTempLines(TempPurchLine, IsHandled, PurchaseHeader);        if not IsHandled then begin            OnPostUpdateCreditMemoLineOnBeforeTempPurchLineSetFilters(TempPurchLine);            TempPurchLine.SetFilter("Return Shipment No.", '<>%1', '');            TempPurchLine.SetFilter(Type, '<>%1', TempPurchLine.Type::" ");            if TempPurchLine.FindSet() then                repeat                    ReturnShptLine.Get(TempPurchLine."Return Shipment No.", TempPurchLine."Return Shipment Line No.");                    PurchOrderLine.Get(                      PurchOrderLine."Document Type"::"Return Order",                      ReturnShptLine."Return Order No.", ReturnShptLine."Return Order Line No.");                    if TempPurchLine.Type = TempPurchLine.Type::"Charge (Item)" then                        UpdatePurchOrderChargeAssgnt(TempPurchLine, PurchOrderLine);                    PurchOrderLine."Quantity Invoiced" :=                      PurchOrderLine."Quantity Invoiced" + TempPurchLine."Qty. to Invoice";                    PurchOrderLine."Qty. Invoiced (Base)" :=                      PurchOrderLine."Qty. Invoiced (Base)" + TempPurchLine."Qty. to Invoice (Base)";                    if Abs(PurchOrderLine."Quantity Invoiced") > Abs(PurchOrderLine."Return Qty. Shipped") then                        Error(InvoiceMoreThanShippedErr, PurchOrderLine."Document No.");                    OnPostUpdateCreditMemoLineOnBeforeInitQtyToInvoice(PurchOrderLine, TempPurchLine);                    PurchOrderLine.InitQtyToInvoice();                    PurchOrderLine.InitOutstanding();                    PurchOrderLine.Modify();                    OnPostUpdateCreditMemoLineOnAfterPurchOrderLineModify(PurchOrderLine, TempPurchLine, ReturnShptLine);                until TempPurchLine.Next() = 0;        end;        OnAfterPostUpdateCreditMemoLine(TempPurchLine);    end;    local procedure PostUpdateOrderNo(var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr.")    var        PurchCrMemoLine: Record "Purch. Cr. Memo Line";        NoOfLines: Integer;        NoOfLinesWithShipmentNo: Integer;        NoOfLinesWithParticularShipmentNo: Integer;    begin        // Do not change 'Return Order No.' if already set         if PurchCrMemoHdr."Return Order No." <> '' then            exit;        PurchCrMemoLine.SetLoadFields("Order No.");        // Get number of lines. Ignore comment lines        PurchCrMemoLine.SetRange("Document No.", PurchCrMemoHdr."No.");        PurchCrMemoLine.SetFilter(Type, '<>%1', PurchCrMemoLine.Type::" "); // Ignore Comment lines        NoOfLines := PurchCrMemoLine.Count();        if NoOfLines = 0 then            exit;        // Get number of lines with filled in 'Order No.'        PurchCrMemoLine.SetFilter(PurchCrMemoLine."Order No.", '<>%1', '');        NoOfLinesWithShipmentNo := PurchCrMemoLine.Count();        if not PurchCrMemoLine.FindFirst() then            exit;        // Get number of lines with filled with a 'Order No.'        PurchCrMemoLine.SetRange("Order No.", PurchCrMemoLine."Order No.");        NoOfLinesWithParticularShipmentNo := PurchCrMemoLine.Count();        PurchCrMemoLine.SetRange("Return Shipment No.");        if (NoOfLines = NoOfLinesWithShipmentNo) and (NoOfLinesWithShipmentNo = NoOfLinesWithParticularShipmentNo) then begin            PurchCrMemoHdr.Validate("Return Order No.", PurchCrMemoLine."Order No.");            PurchCrMemoHdr.Modify(true);        end;    end;    /// <summary>    /// Sets global posting flags (Ship/Receive/Invoice) based on the purchase document type    /// </summary>    /// <remarks>    /// If none of the global posting flags (Ship/Receive/Invoice) is set an error is raised.    /// </remarks>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    procedure SetPostingFlags(var PurchHeader: Record "Purchase Header")    begin        case PurchHeader."Document Type" of            PurchHeader."Document Type"::Order:                PurchHeader.Ship := false;            PurchHeader."Document Type"::Invoice:                begin                    PurchHeader.Receive := true;                    PurchHeader.Invoice := true;                    PurchHeader.Ship := false;                end;            PurchHeader."Document Type"::"Return Order":                PurchHeader.Receive := false;            PurchHeader."Document Type"::"Credit Memo":                begin                    PurchHeader.Receive := false;                    PurchHeader.Invoice := true;                    PurchHeader.Ship := true;                end;        end;        CheckReceiveInvoiceShip(PurchHeader);        OnAfterSetPostingFlags(PurchHeader);    end;    local procedure CheckReceiveInvoiceShip(var PurchHeader: Record "Purchase Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckReceiveInvoiceShip(PurchHeader, IsHandled);        if IsHandled then            exit;        if not (PurchHeader.Receive or PurchHeader.Invoice or PurchHeader.Ship) then            Error(ReceiveInvoiceShipErr);    end;    local procedure SetCheckApplToItemEntry(PurchLine: Record "Purchase Line"; PurchaseHeader: Record "Purchase Header"; ItemJournalLine: Record "Item Journal Line") Result: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetCheckApplToItemEntry(PurchLine, Result, IsHandled, PurchaseHeader, ItemJournalLine);        if IsHandled then            exit(Result);        exit(            PurchSetup."Exact Cost Reversing Mandatory" and (PurchLine.Type = PurchLine.Type::Item) and            (((PurchLine.Quantity < 0) and (PurchLine."Document Type" in [PurchLine."Document Type"::Order, PurchLine."Document Type"::Invoice])) or            ((PurchLine.Quantity > 0) and PurchLine.IsCreditDocType())) and            (PurchLine."Job No." = ''));    end;    local procedure GetAmountRoundingPrecisionInLCY(DocType: Enum "Purchase Document Type"; DocNo: Code[20]; CurrencyCode: Code[10]) AmountRoundingPrecision: Decimal    var        PurchHeader: Record "Purchase Header";    begin        if CurrencyCode = '' then            exit(GLSetup."Amount Rounding Precision");        PurchHeader.Get(DocType, DocNo);        AmountRoundingPrecision := Currency."Amount Rounding Precision" / PurchHeader."Currency Factor";        if AmountRoundingPrecision < GLSetup."Amount Rounding Precision" then            exit(GLSetup."Amount Rounding Precision");        OnAfterGetAmountRoundingPrecisionInLCY(DocType, DocNo, CurrencyCode, AmountRoundingPrecision);    end;    local procedure CollectPurchaseLineReservEntries(var JobReservEntry: Record "Reservation Entry"; ItemJournalLine: Record "Item Journal Line")    var        ReservationEntry: Record "Reservation Entry";        ItemJnlLineReserve: Codeunit "Item Jnl. Line-Reserve";    begin        if ItemJournalLine."Job No." <> '' then begin            JobReservEntry.DeleteAll();            ItemJnlLineReserve.FindReservEntry(ItemJournalLine, ReservationEntry);            ReservationEntry.ClearTrackingFilter();            if ReservationEntry.FindSet() then                repeat                    JobReservEntry := ReservationEntry;                    JobReservEntry.Insert();                until ReservationEntry.Next() = 0;        end;        OnAfterCollectPurchaseLineReservEntries(JobReservEntry, ItemJournalLine);    end;    /// <summary>    /// Archives drop shipment sales orders that are associated whith the purchase document being posted    /// </summary>    /// <remarks>    /// Sales Orders are retrieved and processed based on the information stored in the variable TempDropShptPostBuffer    /// </remarks>    /// <param name="TempDropShptPostBuffer">Temporary record that holds associated drop shipment line information.</param>    procedure ArchiveSalesOrders(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    var        SalesOrderHeader: Record "Sales Header";        SalesOrderLine: Record "Sales Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeArchiveSalesOrders(TempDropShptPostBuffer, IsHandled);        if IsHandled then            exit;        if TempDropShptPostBuffer.FindSet() then            repeat                SalesOrderHeader.Get(                  SalesOrderHeader."Document Type"::Order,                  TempDropShptPostBuffer."Order No.");                TempDropShptPostBuffer.SetRange("Order No.", TempDropShptPostBuffer."Order No.");                repeat                    SalesOrderLine.Get(                      SalesOrderLine."Document Type"::Order,                      TempDropShptPostBuffer."Order No.", TempDropShptPostBuffer."Order Line No.");                    SalesOrderLine."Qty. to Ship" := TempDropShptPostBuffer.Quantity;                    SalesOrderLine."Qty. to Ship (Base)" := TempDropShptPostBuffer."Quantity (Base)";                    OnArchiveSalesOrdersOnBeforeSalesOrderLineModify(SalesOrderLine, TempDropShptPostBuffer);                    SalesOrderLine.Modify();                until TempDropShptPostBuffer.Next() = 0;                SalesPost.ArchiveUnpostedOrder(SalesOrderHeader);                TempDropShptPostBuffer.SetRange("Order No.");            until TempDropShptPostBuffer.Next() = 0;    end;    local procedure ClearAllVariables()    begin        ClearAll();        TempPurchLineGlobal.DeleteAll();        TempItemChargeAssgntPurch.DeleteAll();        TempHandlingSpecification.DeleteAll();        TempTrackingSpecification.DeleteAll();        TempTrackingSpecificationInv.DeleteAll();        TempWhseSplitSpecification.DeleteAll();        TempValueEntryRelation.DeleteAll();        TempICGenJnlLine.DeleteAll();        TempPrepmtDeductLCYPurchLine.DeleteAll();        TempSKU.DeleteAll();        TempDeferralHeader.DeleteAll();        TempDeferralLine.DeleteAll();        OrderArchived := false;    end;    /// <summary>    /// Set global variable SuppressCommit    /// </summary>    /// <remarks>    /// When SuppressCommit is set to true the data is not committed when posting    /// </remarks>    /// <param name="NewSuppressCommit">New value to suppress commit</param>    procedure SetSuppressCommit(NewSuppressCommit: Boolean)    begin        SuppressCommit := NewSuppressCommit;    end;    local procedure CheckOverReceipt(PurchaseHeader: Record "Purchase Header")    var        OverReceiptPurchaseLine: Record "Purchase Line";        OverReceiptMgt: Codeunit "Over-Receipt Mgt.";    begin        if not OverReceiptMgt.IsOverReceiptAllowed() then            exit;        OverReceiptPurchaseLine.SetRange("Document Type", PurchaseHeader."Document Type");        OverReceiptPurchaseLine.SetRange("Document No.", PurchaseHeader."No.");        OverReceiptPurchaseLine.SetFilter("Over-Receipt Code", '<>%1', '');        if not OverReceiptPurchaseLine.IsEmpty() and (InvtPickPutaway or WhseReceive) then            PurchaseHeader.TestPurchasePrepayment();        OverReceiptPurchaseLine.SetRange("Over-Receipt Approval Status", OverReceiptPurchaseLine."Over-Receipt Approval Status"::Pending);        if not OverReceiptPurchaseLine.IsEmpty() then            Error(OverReceiptApprovalErr);    end;    /// <summary>    /// Retrieves general posting setup based on the posting groups specified on the line and checks if posting setup is not blocked    /// </summary>    /// <param name="GenPostingSetup">Return Value: General Posting Setup</param>    /// <param name="PurchLine">The purchase line of the document that is being posted.</param>    procedure GetGeneralPostingSetup(var GenPostingSetup: Record "General Posting Setup"; PurchLine: Record "Purchase Line")    begin        GenPostingSetup.Get(PurchLine."Gen. Bus. Posting Group", PurchLine."Gen. Prod. Posting Group");        GenPostingSetup.TestField(Blocked, false);        OnAfterGetGeneralPostingSetup(GenPostingSetup, PurchLine);    end;    procedure GetGlobalTempItemChargeAssgntPurch(var TempItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)" temporary)    begin        TempItemChargeAssignmentPurch.Copy(TempItemChargeAssgntPurch, true);    end;    local procedure PostResJnlLine(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line")    var        ResJournalLine: Record "Res. Journal Line";        ResJnlPostLine: Codeunit "Res. Jnl.-Post Line";    begin        if PurchaseLine."Qty. to Invoice" = 0 then            exit;        ResJournalLine.Init();        ResJournalLine.CopyFrom(PurchaseHeader);        ResJournalLine.CopyDocumentFields(GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, PurchaseHeader."Posting No. Series");        ResJournalLine.CopyFrom(PurchaseLine);        ResJnlPostLine.RunWithCheck(ResJournalLine);    end;    /// <summary>    /// Wrapper procedure to populates global temporary table TempItemChargeAssgntPurch and checks if charge quantity does not exceed quantity to invoice    /// If document is being invoiced in full (no remaining quantity) and not all charges have been assigned, an error is raised    /// </summary>    /// <param name="PurchHeader">The purchase header of the document that is being posted.</param>    procedure RunCopyAndCheckItemCharge(PurchaseHeader: Record "Purchase Header")    begin        CopyAndCheckItemCharge(PurchaseHeader);    end;#if not CLEAN28    /// <summary>    /// Checks if Sales Order line associated with the purchase line does not exeed quantity on the purhcase line. Error is raised if the quantity is exeeded    /// </summary>    /// <remarks>    /// Sales Order line must exist otherwise an error is raised    /// </remarks>    /// <param name="PurchaseLine">The purchase line of the document that is being posted.</param>    [Obsolete('This procedure is no longer used.', '28.0')]    procedure CheckAssociatedSalesOrderLine(PurchaseLine: Record "Purchase Line")    var        SalesLine: Record "Sales Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckAssociatedSalesOrderLine(PurchaseLine, IsHandled);        if IsHandled then            exit;        SalesLine.Get(SalesLine."Document Type"::Order, PurchaseLine."Sales Order No.", PurchaseLine."Sales Order Line No.");        if Abs(PurchaseLine.Quantity - PurchaseLine."Quantity Invoiced") < Abs(SalesLine.Quantity - SalesLine."Quantity Invoiced") then            Error(CannotPostBeforeAssosSalesOrderErr, PurchaseLine."Sales Order No.");    end;#endif    local procedure PurchRcptLineInsert(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchLine: Record "Purchase Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePurchRcptLineInsert(PurchRcptLine, PurchRcptHeader, PurchLine, SuppressCommit, PostedWhseRcptLine, IsHandled, ItemLedgShptEntryNo);        if IsHandled then            exit;        PurchRcptLine.Insert(true);        MatchedOrderLineMgmt.InsertMatchedOrderLineReceipt(PurchLine, PurchRcptLine);        OnAfterPurchRcptLineInsert(PurchLine, PurchRcptLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit, PurchInvHeader, TempTrackingSpecification, PurchRcptHeader, TempWhseRcptHeader, xPurchLine, TempPurchLineGlobal);    end;    local procedure NeedUpdateGenProdPostingGroupOnItemChargeOnPurchaseLine(PurchaseLine: Record "Purchase Line"): Boolean    var        NeedUpdate: Boolean;        IsHandled: Boolean;    begin        NeedUpdate := true;        IsHandled := false;        OnNeedUpdateGenProdPostingGroupOnItemChargeOnPurchaseLine(PurchaseLine, NeedUpdate, IsHandled);        if IsHandled then            exit(NeedUpdate);        if PurchaseLine.Type <> PurchaseLine.Type::"Charge (Item)" then            exit(false);        if PurchaseLine."No." = '' then            exit(false);        if ((PurchaseLine.Type = PurchaseLine.Type::"Charge (Item)") and (PurchaseLine."Gen. Prod. Posting Group" <> '')) then            exit(false);        exit(true);    end;    local procedure NeedUpdateGenProdPostingGroupOnItemChargeOnPurchRcptLine(PurchRcptLine: Record "Purch. Rcpt. Line"): Boolean    var        NeedUpdate: Boolean;        IsHandled: Boolean;    begin        NeedUpdate := true;        IsHandled := false;        OnNeedUpdateGenProdPostingGroupOnItemChargeOnPurchRcptLine(PurchRcptLine, NeedUpdate, IsHandled);        if IsHandled then            exit(NeedUpdate);        if PurchRcptLine.Type <> PurchRcptLine.Type::"Charge (Item)" then            exit(false);        if PurchRcptLine."No." = '' then            exit(false);        if ((PurchRcptLine.Type = PurchRcptLine.Type::"Charge (Item)") and (PurchRcptLine."Gen. Prod. Posting Group" <> '')) then            exit(false);        exit(true);    end;    local procedure NeedUpdateGenProdPostingGroupOnItemChargeOnReturnReturnShipmentLine(ReturnShipmentLine: Record "Return Shipment Line"): Boolean    var        NeedUpdate: Boolean;        IsHandled: Boolean;    begin        NeedUpdate := true;        IsHandled := false;        OnNeedUpdateGenProdPostingGroupOnItemChargeOnReturnShipmentLine(ReturnShipmentLine, NeedUpdate, IsHandled);        if IsHandled then            exit(NeedUpdate);        if ReturnShipmentLine.Type <> ReturnShipmentLine.Type::"Charge (Item)" then            exit(false);        if ReturnShipmentLine."No." = '' then            exit(false);        if ((ReturnShipmentLine.Type = ReturnShipmentLine.Type::"Charge (Item)") and (ReturnShipmentLine."Gen. Prod. Posting Group" <> '')) then            exit(false);        exit(true);    end;    /// <summary>    /// Checks and updates General Product Posting Group on purchase receipt line from Item Charge    /// </summary>    /// <remarks>    /// General Product Posting Group is only updated for lines that relate to Charge (Item) and General Product Posting Group is empty    /// If either Item Charge doesn't exist or General Product Posting Group is empty on Item Charge, an error is raised    /// </remarks>    /// <param name="PurchRcptLine">Rurchase receipt line to be updated, that relates to purchase document is being posted</param>    procedure UpdateChargeItemPurchaseRcptLineGenProdPostingGroup(var PurchRcptLine: Record "Purch. Rcpt. Line");    var        ItemCharge: Record "Item Charge";    begin        if not NeedUpdateGenProdPostingGroupOnItemChargeOnPurchRcptLine(PurchRcptLine) then            exit;        ItemCharge.Get(PurchRcptLine."No.");        ItemCharge.TestField("Gen. Prod. Posting Group");        PurchRcptLine."Gen. Prod. Posting Group" := ItemCharge."Gen. Prod. Posting Group";        PurchRcptLine.Modify(false);    end;    /// <summary>    /// Checks and updates General Product Posting Group on return shipment line from Item Charge    /// </summary>    /// <remarks>    /// General Product Posting Group is only updated for lines that relate to Charge (Item) and General Product Posting Group is empty    /// If either Item Charge doesn't exist or General Product Posting Group is empty on Item Charge, an error is raised    /// </remarks>    /// <param name="ReturnShipmentLine">Return shipment line to be updated, that relates to purchase document is being posted</param>    procedure UpdateChargeItemReturnShptLineGenProdPostingGroup(var ReturnShipmentLine: Record "Return Shipment Line");    var        ItemCharge: Record "Item Charge";    begin        if not NeedUpdateGenProdPostingGroupOnItemChargeOnReturnReturnShipmentLine(ReturnShipmentLine) then            exit;        ItemCharge.Get(ReturnShipmentLine."No.");        ItemCharge.TestField("Gen. Prod. Posting Group");        ReturnShipmentLine."Gen. Prod. Posting Group" := ItemCharge."Gen. Prod. Posting Group";        ReturnShipmentLine.Modify(false);    end;    /// <summary>    /// Checks and updates General Product Posting Group on purchase line from Item Charge    /// </summary>    /// <remarks>    /// General Product Posting Group is only updated for lines that relate to Charge (Item) and General Product Posting Group is empty    /// If either Item Charge doesn't exist or General Product Posting Group is empty on Item Charge, an error is raised    /// </remarks>    /// <param name="PurchaseLine">Purchase line to be updated before posting.</param>    procedure UpdateChargeItemPurchaseLineGenProdPostingGroup(var PurchaseLine: Record "Purchase Line");    var        ItemCharge: Record "Item Charge";    begin        if not NeedUpdateGenProdPostingGroupOnItemChargeOnPurchaseLine(PurchaseLine) then            exit;        ItemCharge.Get(PurchaseLine."No.");        ItemCharge.TestField("Gen. Prod. Posting Group");        PurchaseLine."Gen. Prod. Posting Group" := ItemCharge."Gen. Prod. Posting Group";        PurchaseLine.Modify(false);    end;    local procedure ValidateJobLineType(PurchLine: Record "Purchase Line")    var        Confirmed: Boolean;        HideDialog: Boolean;        IsHandled: Boolean;    begin        if PurchLine."Job Line Type" <> PurchLine."Job Line Type"::" " then            exit;        OnBeforeConfirmJobLineType(PurchLine, HideDialog, IsHandled);        if not IsHandled then            if not HideDialog then begin                Confirmed := Confirm(ConfirmUsageWithBlankLineTypeQst, false);                if not Confirmed then                    Error('');            end;    end;    local procedure ValidateMatchingJobPlanningLine(PurchLine: Record "Purchase Line")    var        JobPlanningLine: Record "Job Planning Line";        Confirmed: Boolean;        HideDialog: Boolean;        IsHandled: Boolean;    begin        JobPlanningLine.SetCurrentKey(Type, "No.", "Job No.", "Job Task No.", "Usage Link", "System-Created Entry");        case PurchLine.Type of            PurchLine.Type::"G/L Account":                JobPlanningLine.SetRange(Type, JobPlanningLine.Type::"G/L Account");            PurchLine.Type::Item:                JobPlanningLine.SetRange(Type, JobPlanningLine.Type::Item);            PurchLine.Type::Resource:                JobPlanningLine.SetRange(Type, JobPlanningLine.Type::Resource);            PurchLine.Type::" ":                JobPlanningLine.SetRange(Type, JobPlanningLine.Type::Text);        end;        JobPlanningLine.SetRange("No.", PurchLine."No.");        JobPlanningLine.SetRange("Job No.", PurchLine."Job No.");        JobPlanningLine.SetRange("Job Task No.", PurchLine."Job Task No.");        JobPlanningLine.SetRange("Usage Link", true);        JobPlanningLine.SetRange("System-Created Entry", false);        if not JobPlanningLine.IsEmpty() then begin            if PurchLine."Job Planning Line No." = 0 then begin                OnBeforeConfirmJobPlanningLineNo(PurchLine, HideDialog, IsHandled);                if not IsHandled then                    if not HideDialog then begin                        Confirmed := Confirm(ConfirmUsageWithBlankJobPlanningLineNoQst, false);                        if not Confirmed then                            Error('');                    end;            end;            ValidateJobLineType(PurchLine);        end;    end;    local procedure CheckPostingDate(var PurchaseHeader: Record "Purchase Header")    var        GenJnlCheckLine: Codeunit "Gen. Jnl.-Check Line";        ForwardLinkMgt: Codeunit "Forward Link Mgt.";        SetupRecID: RecordID;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckPostingDate(PurchaseHeader, IsHandled);        if not IsHandled then            if GenJnlCheckLine.IsDateNotAllowed(PurchaseHeader."Posting Date", SetupRecID, PurchaseHeader."Journal Templ. Name") then                ErrorMessageMgt.LogContextFieldError(                    PurchaseHeader.FieldNo("Posting Date"), StrSubstNo(PostingDateNotAllowedErr, PurchaseHeader.FieldCaption("Posting Date")),                    SetupRecID, ErrorMessageMgt.GetFieldNo(SetupRecID.TableNo, GLSetup.FieldName("Allow Posting From")),                    ForwardLinkMgt.GetHelpCodeForAllowedPostingDate());    end;    local procedure CheckVATDate(var PurchaseHeader: Record "Purchase Header")    begin        // ensure VAT Date is filled in        if PurchaseHeader."VAT Reporting Date" = 0D then begin            PurchaseHeader."VAT Reporting Date" := GLSetup.GetVATDate(PurchaseHeader."Posting Date", PurchaseHeader."Document Date");            PurchaseHeader.Modify();        end;    end;    local procedure UpdateReceivingNoTelemetry(var PurchaseHeader: Record "Purchase Header")    var        TelemetryCustomDimensions: Dictionary of [Text, Text];        PreviewTokenFoundLbl: Label 'Preview token %1 found on fields.', Locked = true;        PreviewToken: Text;    begin        if not Format(PurchaseHeader."Receiving No.").StartsWith(PostingPreviewNoTok) and           not Format(PurchaseHeader."Return Shipment No.").StartsWith(PostingPreviewNoTok) and           not Format(PurchaseHeader."Posting No.").StartsWith(PostingPreviewNoTok)        then            exit;        TelemetryCustomDimensions.Add(PurchaseHeader.FieldCaption(SystemId), PurchaseHeader.SystemId);        TelemetryCustomDimensions.Add(PurchaseHeader.FieldCaption("Document Type"), Format(PurchaseHeader."Document Type"));        if Format(PurchaseHeader."Receiving No.").StartsWith(PostingPreviewNoTok) then begin            PreviewToken := PurchaseHeader."Receiving No.";            TelemetryCustomDimensions.Add(PurchaseHeader.FieldCaption("Receiving No."), PurchaseHeader."Receiving No.");            PurchaseHeader."Receiving No." := '';        end;        if Format(PurchaseHeader."Return Shipment No.").StartsWith(PostingPreviewNoTok) then begin            PreviewToken := PurchaseHeader."Return Shipment No.";            TelemetryCustomDimensions.Add(PurchaseHeader.FieldCaption("Return Shipment No."), PurchaseHeader."Return Shipment No.");            PurchaseHeader."Return Shipment No." := '';        end;        if Format(PurchaseHeader."Posting No.").StartsWith(PostingPreviewNoTok) then begin            PreviewToken := PurchaseHeader."Posting No.";            TelemetryCustomDimensions.Add(PurchaseHeader.FieldCaption("Posting No."), PurchaseHeader."Posting No.");            PurchaseHeader."Posting No." := '';        end;        Session.LogMessage('0000CUW', StrSubstNo(PreviewTokenFoundLbl, PreviewToken), Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::All, TelemetryCustomDimensions);    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 DeleteItemChargeLines(var ItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)")    begin        ItemChargeAssgntPurch.SetFilter("Applies-to Doc. Line No.", '<>%1', ItemChargeAssgntPurch."Applies-to Doc. Line No.");        ItemChargeAssgntPurch.DeleteAll();    end;    local procedure UpdateReceiptInvoicingQuantities(        var QtyToBeInvoiced: Decimal;        var QtyToBeInvoicedBase: Decimal;        TrackingSpecificationExists: Boolean;        PurchLine: Record "Purchase Line";        PurchRcptLine: Record "Purch. Rcpt. Line";        var TempTrackingSpecification: Record "Tracking Specification" temporary;        RemQtyToInvoiceCurrLine: Decimal;        RemQtyToInvoiceCurrLineBase: Decimal)    var        SkipQuantityUpdate: Boolean;    begin        SkipQuantityUpdate := false;        OnBeforeUpdateReceiptInvoicingQuantities(PurchLine, SkipQuantityUpdate);        if SkipQuantityUpdate then            exit;        UpdateQtyToBeInvoicedForReceipt(            QtyToBeInvoiced,            QtyToBeInvoicedBase,            TrackingSpecificationExists,            PurchLine,            PurchRcptLine,            TempTrackingSpecification);        if TrackingSpecificationExists then begin            TempTrackingSpecification."Quantity actual Handled (Base)" := QtyToBeInvoicedBase;            TempTrackingSpecification.Modify(false);        end;        if TrackingSpecificationExists then            AdjustQuantityRoundingForReceipt(                PurchRcptLine,                RemQtyToInvoiceCurrLine,                QtyToBeInvoiced,                RemQtyToInvoiceCurrLineBase,                QtyToBeInvoicedBase);        RemQtyToBeInvoiced := RemQtyToBeInvoiced - QtyToBeInvoiced;        RemQtyToBeInvoicedBase := RemQtyToBeInvoicedBase - QtyToBeInvoicedBase;    end;    local procedure SetExternalDocumentNo(): Code[35]    begin        if PurchRcptHeader."Vendor Shipment No." <> '' then            exit(PurchRcptHeader."Vendor Shipment No.");        exit(GenJnlLineExtDocNo);    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 CreatePrepaymentLineForCreditMemo(var PurchaseHeader: Record "Purchase Header")    var        GLAccount: Record "G/L Account";        PurchaseLine: Record "Purchase Line";        PurchaseInvoiceLine: Record "Purch. Inv. Line";        GeneralPostingSetup: Record "General Posting Setup";        TempPrepmtPurchaseLine: Record "Purchase Line" temporary;        TempExtendedTextLine: Record "Extended Text Line" temporary;        TransferExtendedText: Codeunit "Transfer Extended Text";        LineNo: Integer;    begin        if not CheckApplicationExistForCreditMemo(PurchaseHeader) then            exit;        PurchaseLine.SetRange("Document Type", PurchaseHeader."Document Type");        PurchaseLine.SetRange("Document No.", PurchaseHeader."No.");        if PurchaseLine.FindLast() then            LineNo := PurchaseLine."Line No." + 10000        else            LineNo := 10000;        TempPrepmtPurchaseLine.SetHasBeenShown();        PurchaseInvoiceLine.SetRange("Document No.", PurchaseHeader."Applies-to Doc. No.");        PurchaseInvoiceLine.SetRange("Prepayment Line", true);        if PurchaseInvoiceLine.FindSet() then            repeat                GeneralPostingSetup.Get(PurchaseInvoiceLine."Gen. Bus. Posting Group", PurchaseInvoiceLine."Gen. Prod. Posting Group");                GLAccount.Get(GeneralPostingSetup.GetPurchPrepmtAccount());                TempPrepmtPurchaseLine.Init();                TempPrepmtPurchaseLine."Document Type" := PurchaseHeader."Document Type";                TempPrepmtPurchaseLine."Document No." := PurchaseHeader."No.";                TempPrepmtPurchaseLine."Line No." := LineNo;                TempPrepmtPurchaseLine."System-Created Entry" := true;                TempPrepmtPurchaseLine.Validate(Type, TempPrepmtPurchaseLine.Type::"G/L Account");                TempPrepmtPurchaseLine.Validate("No.", PurchaseInvoiceLine."No.");                TempPrepmtPurchaseLine.Validate(Quantity, -1);                TempPrepmtPurchaseLine."Qty. to Receive" := TempPrepmtPurchaseLine.Quantity;                TempPrepmtPurchaseLine."Qty. to Invoice" := TempPrepmtPurchaseLine.Quantity;                TempPrepmtPurchaseLine.Validate("Direct Unit Cost", PurchaseInvoiceLine."Direct Unit Cost");                TempPrepmtPurchaseLine.Validate("Qty. to Invoice", TempPrepmtPurchaseLine.Quantity);                TempPrepmtPurchaseLine.Validate("Prepayment Line", true);                TempPrepmtPurchaseLine.Validate("Shortcut Dimension 1 Code", PurchaseInvoiceLine."Shortcut Dimension 1 Code");                TempPrepmtPurchaseLine.Validate("Shortcut Dimension 2 Code", PurchaseInvoiceLine."Shortcut Dimension 2 Code");                TempPrepmtPurchaseLine.Validate("Dimension Set ID", PurchaseInvoiceLine."Dimension Set ID");                LineNo := LineNo + 10000;                TempPrepmtPurchaseLine.Insert(true);                TransferExtendedText.PrepmtGetAnyExtText(                    TempPrepmtPurchaseLine."No.",                    DATABASE::"Purch. Cr. Memo Line",                    PurchaseHeader."Document Date",                    PurchaseHeader."Language Code",                    TempExtendedTextLine);                if TempExtendedTextLine.FindSet() then                    repeat                        TempPrepmtPurchaseLine.Init();                        TempPrepmtPurchaseLine.Validate(Description, TempExtendedTextLine.Text);                        TempPrepmtPurchaseLine.Validate("System-Created Entry", true);                        TempPrepmtPurchaseLine.Validate("Prepayment Line", true);                        TempPrepmtPurchaseLine.Validate("Line No.", LineNo);                        LineNo := LineNo + 10000;                        TempPrepmtPurchaseLine.Insert(true);                    until TempExtendedTextLine.Next() = 0;            until PurchaseInvoiceLine.Next() = 0;        if TempPrepmtPurchaseLine.FindSet() then            repeat                TempPurchLineGlobal := TempPrepmtPurchaseLine;                TempPurchLineGlobal.Insert(true);            until TempPrepmtPurchaseLine.Next() = 0;    end;    local procedure UpdateVendorInvoiceNoForSelfBilling(var PurchHeader: Record "Purchase Header")    var        Vendor: Record Vendor;        NoSeries: Codeunit "No. Series";        SelfBillingNoSeriesCode: Code[20];    begin        if not (PurchHeader."Document Type" in [PurchHeader."Document Type"::Invoice, PurchHeader."Document Type"::Order]) then            exit;        SelfBillingNoSeriesCode := GetSelfBillingInvoiceNoSeries(PurchHeader);        if SelfBillingNoSeriesCode = '' then            Error(                SelfBillingNoSeriesMissingErr,                Vendor.FieldCaption("Self-Billing Invoice Nos."),                PurchHeader."Buy-from Vendor No.",                PurchSetup.FieldCaption("Posted Self-Billing Inv. Nos."),                PurchSetup.TableCaption());        if PreviewMode then            PurchHeader."Vendor Invoice No." := PostingPreviewNoTok        else            PurchHeader."Vendor Invoice No." := NoSeries.GetNextNo(SelfBillingNoSeriesCode, PurchHeader."Posting Date");    end;    local procedure GetSelfBillingInvoiceNoSeries(PurchHeader: Record "Purchase Header"): Code[20]    var        Vendor: Record Vendor;    begin        Vendor.SetLoadFields("Self-Billing Invoice Nos.");        if Vendor.Get(PurchHeader."Buy-from Vendor No.") and (Vendor."Self-Billing Invoice Nos." <> '') then            exit(Vendor."Self-Billing Invoice Nos.");        PurchSetup.GetRecordOnce();        exit(PurchSetup."Posted Self-Billing Inv. Nos.");    end;    local procedure SelfBillingInvoiceDocument(PurchHeader: Record "Purchase Header"): Boolean    begin        if not PurchHeader."Self-Billing Invoice" then            exit(false);        exit(PurchHeader."Document Type" in [PurchHeader."Document Type"::Order, PurchHeader."Document Type"::Invoice]);    end;    local procedure CheckApplicationExistForCreditMemo(PurchaseHeader: Record "Purchase Header"): Boolean    begin        if not (PurchaseHeader."Document Type" = PurchaseHeader."Document Type"::"Credit Memo") then            exit(false);        if (PurchaseHeader."Applies-to Doc. Type" <> PurchaseHeader."Applies-to Doc. Type"::" ") and           (PurchaseHeader."Applies-to Doc. No." <> '')        then            exit(true);    end;    local procedure GetInventorySetup()    begin        if not InvtSetupRead then            InventorySetup.Get();        InvtSetupRead := true;    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;    [IntegrationEvent(false, false)]    local procedure OnArchiveSalesOrdersOnBeforeSalesOrderLineModify(var SalesOrderLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterBlanketOrderPurchLineModify(var BlanketOrderPurchLine: Record "Purchase Line"; PurchaseLine: Record "Purchase Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckPurchDoc(var PurchHeader: Record "Purchase Header"; CommitIsSupressed: Boolean; WhseShip: Boolean; WhseReceive: Boolean; PreviewMode: Boolean; var ErrorMessageMgt: Codeunit "Error Message Management")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckAndUpdate(var PurchaseHeader: Record "Purchase Header"; CommitIsSuppressed: Boolean; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterCheckTrackingSpecification(PurchaseHeader: Record "Purchase Header"; var TempItemPurchaseLine: Record "Purchase Line" temporary);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckTrackingAndWarehouseForReceive(var PurchaseHeader: Record "Purchase Header"; var Receive: Boolean; CommitIsSupressed: Boolean; var TempWarehouseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckTrackingAndWarehouseForShip(var PurchaseHeader: Record "Purchase Header"; var Ship: Boolean; CommitIsSupressed: Boolean; var TempPurchaseLine: Record "Purchase Line" temporary; var TempWarehouseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateJobPurchLine(var JobPurchaseLine: Record "Purchase Line"; PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateWhseJnlLine(PurchaseLine: Record "Purchase Line"; var TempWhseJnlLine: record "Warehouse Journal Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterDeleteAfterPosting(PurchHeader: Record "Purchase Header"; PurchInvHeader: Record "Purch. Inv. Header"; PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterDeleteApprovalEntries(var PurchaseHeader: Record "Purchase Header"; var PurchInvHeader: Record "Purch. Inv. Header"; PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; PurchRcptHeader: Record "Purch. Rcpt. Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterDivideAmount(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; QtyType: Option General,Invoicing,Shipping; PurchLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetAmountRoundingPrecisionInLCY(DocType: Enum "Purchase Document Type"; DocNo: Code[20]; CurrencyCode: Code[10]; var AmountRoundingPrecision: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetLineDataFromOrder(var PurchLine: Record "Purchase Line"; PurchOrderLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetPurchSetup(var PurchSetup: Record "Purchases & Payables Setup")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterModifyTempLine(var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    procedure OnAfterPostPurchaseDoc(var PurchaseHeader: Record "Purchase Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; PurchRcpHdrNo: Code[20]; RetShptHdrNo: Code[20]; PurchInvHdrNo: Code[20]; PurchCrMemoHdrNo: Code[20]; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostPurchaseDocDropShipment(SalesShptNo: Code[20]; CommitIsSupressed: Boolean; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterRetrieveInvoiceTrackingSpecificationIfExists(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdatePostingNos(var PurchaseHeader: Record "Purchase Header"; CommitIsSupressed: Boolean; PreviewMode: Boolean; var ModifyHeader: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckMandatoryFields(var PurchaseHeader: Record "Purchase Header"; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterFinalizePosting(var PurchHeader: Record "Purchase Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var ReturnShptHeader: Record "Return Shipment Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; PreviewMode: Boolean; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterFinalizePostingOnBeforeCommit(var PurchHeader: Record "Purchase Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var ReturnShptHeader: Record "Return Shipment Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; PreviewMode: Boolean; CommitIsSupressed: Boolean; EverythingInvoiced: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterIncrAmount(var TotalPurchLine: Record "Purchase Line"; PurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitAssocItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; PurchaseHeader: Record "Purchase Header"; QtyToBeShipped: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertCombinedSalesShipment(var SalesShipmentHeader: Record "Sales Shipment Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertPostedHeaders(var PurchaseHeader: Record "Purchase Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var ReturnShptHeader: Record "Return Shipment Header"; var PurchSetup: Record "Purchases & Payables Setup"; var Window: Dialog)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertReceiptHeader(var PurchHeader: Record "Purchase Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; WhseReceive: Boolean; CommitIsSuppressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertReturnShipmentHeader(var PurchHeader: Record "Purchase Header"; var ReturnShptHeader: Record "Return Shipment Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInvoiceRoundingAmount(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var TotalPurchaseLine: Record "Purchase Line"; UseTempData: Boolean; InvoiceRoundingAmount: Decimal; CommitIsSuppressed: Boolean; RoundingLineInserted: Boolean; RoundingLineNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertedPrepmtVATBaseToDeduct(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; PrepmtLineNo: Integer; TotalPrepmtAmtToDeduct: Decimal; var TempPrepmtDeductLCYPurchLine: Record "Purchase Line" temporary; var PrepmtVATBaseToDeduct: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostAssocItemJnlLine(var ItemJnlLine: Record "Item Journal Line"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var SalesLineOrder: Record "Sales Line"; var SalesOrderHeader: Record "Sales Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostCombineSalesOrderShipment(var PurchaseHeader: Record "Purchase Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;#if not CLEAN27    internal procedure RunOnAfterPostItemJnlLineCopyProdOrder(var ItemJnlLine: Record "Item Journal Line"; PurchLine: Record "Purchase Line"; PurchRcptHeader2: Record "Purch. Rcpt. Header"; QtyToBeReceived: Decimal; CommitIsSupressed: Boolean; QtyToBeInvoiced: Decimal)    begin        OnAfterPostItemJnlLineCopyProdOrder(ItemJnlLine, PurchLine, PurchRcptHeader2, QtyToBeReceived, CommitIsSupressed, QtyToBeInvoiced);    end;    [Obsolete('Moved to codeunit MfgPurchPost', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemJnlLineCopyProdOrder(var ItemJnlLine: Record "Item Journal Line"; PurchLine: Record "Purchase Line"; PurchRcptHeader: Record "Purch. Rcpt. Header"; QtyToBeReceived: Decimal; CommitIsSupressed: Boolean; QtyToBeInvoiced: Decimal)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemJnlLineItemCharges(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemChargePerOrder(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemTrackingLine(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; WhseReceive: Boolean; WhseShip: Boolean; InvtPickPutaway: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostUpdateCreditMemoLine(var PurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostUpdateInvoiceLine(var PurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPurchRcptHeaderInsert(var PurchRcptHeader: Record "Purch. Rcpt. Header"; var PurchaseHeader: Record "Purchase Header"; CommitIsSupressed: Boolean; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPurchRcptLineInsert(PurchaseLine: Record "Purchase Line"; var PurchRcptLine: Record "Purch. Rcpt. Line"; ItemLedgShptEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSupressed: Boolean; PurchInvHeader: Record "Purch. Inv. Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary; PurchRcptHeader: Record "Purch. Rcpt. Header"; TempWhseRcptHeader: Record "Warehouse Receipt Header"; xPurchLine: Record "Purchase Line"; var TempPurchLineGlobal: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPurchInvHeaderInsert(var PurchInvHeader: Record "Purch. Inv. Header"; var PurchHeader: Record "Purchase Header"; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPurchInvLineInsert(var PurchInvLine: Record "Purch. Inv. Line"; PurchInvHeader: Record "Purch. Inv. Header"; PurchLine: Record "Purchase Line"; ItemLedgShptEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSupressed: Boolean; PurchHeader: Record "Purchase Header"; PurchRcptHeader: Record "Purch. Rcpt. Header"; TempWhseRcptHeader: Record "Warehouse Receipt Header"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPurchCrMemoHeaderInsert(var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var PurchHeader: Record "Purchase Header"; CommitIsSupressed: Boolean; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPurchCrMemoLineInsert(var PurchCrMemoLine: Record "Purch. Cr. Memo Line"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var PurchLine: Record "Purchase Line"; CommitIsSupressed: Boolean; var PurchaseHeader: Record "Purchase Header"; GenJnlLineDocNo: Code[20]; RoundingLineInserted: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterReturnShptHeaderInsert(var ReturnShptHeader: Record "Return Shipment Header"; var PurchHeader: Record "Purchase Header"; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterReturnShptLineInsert(var ReturnShptLine: Record "Return Shipment Line"; ReturnShptHeader: Record "Return Shipment Header"; PurchLine: Record "Purchase Line"; ItemLedgShptEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSupressed: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; xPurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterRevertWarehouseEntry(var TempWhseJnlLine: Record "Warehouse Journal Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSalesShptHeaderInsert(var SalesShipmentHeader: Record "Sales Shipment Header"; SalesOrderHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSalesShptLineInsert(var SalesShptLine: Record "Sales Shipment Line"; SalesShptHeader: Record "Sales Shipment Header"; SalesOrderLine: Record "Sales Line"; CommitIsSuppressed: Boolean; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer"; var TempPurchLineGlobal: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostAccICLine(PurchaseLine: Record "Purchase Line"; CommitIsSupressed: Boolean; var PurchaseHeader: Record "Purchase Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr.")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostItemLine(PurchaseLine: Record "Purchase Line"; CommitIsSupressed: Boolean; PurchaseHeader: Record "Purchase Header"; RemQtyToBeInvoiced: Decimal; RemQtyToBeInvoicedBase: Decimal; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var PurchaseLine: Record "Purchase Line"; var PurchaseHeader: Record "Purchase Header"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var WhseJnlRegisterLine: Codeunit "Whse. Jnl.-Register Line"; var WhseReceive: Boolean; var WhseShip: Boolean; var WhseRcptHeader: Record "Warehouse Receipt Header"; var WhseShptHeader: Record "Warehouse Shipment Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostWhseJnlLine(var PurchaseLine: Record "Purchase Line"; ItemLedgEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostUpdateOrderLine(var PurchaseLine: Record "Purchase Line"; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostInvoice(var PurchHeader: Record "Purchase Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; TotalPurchLine: Record "Purchase Line"; TotalPurchLineLCY: Record "Purchase Line"; CommitIsSupressed: Boolean; var VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostPurchLine(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; CommitIsSupressed: Boolean; var PurchInvLine: Record "Purch. Inv. Line"; var PurchCrMemoLine: Record "Purch. Cr. Memo Line"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var PurchLineACY: Record "Purchase Line"; GenJnlLineDocType: Enum "Gen. Journal Document Type"; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; SrcCode: Code[10]; xPurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterProcessPurchLines(var PurchHeader: Record "Purchase Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var ReturnShipmentHeader: Record "Return Shipment Header"; WhseShip: Boolean; WhseReceive: Boolean; var PurchLinesProcessed: Boolean; CommitIsSuppressed: Boolean; EverythingInvoiced: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterProcessAssocItemJnlLine(var PurchLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterReleasePurchDoc(var PurchHeader: Record "Purchase Header");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterRefreshTempLines(var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterResetTempLines(var TempPurchLineGlobal: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterRestorePurchaseHeader(var PurchaseHeader: Record "Purchase Header"; PurchaseHeaderCopy: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterReverseAmount(var PurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterRoundAmount(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; PurchLineQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSaveTempWhseSplitSpec(PurchaseLine: Record "Purchase Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSetPostingFlags(var PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterTestPurchLine(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; WhseReceive: Boolean; WhseShip: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateInvoicedQtyOnPurchRcptLine(var PurchInvHeader: Record "Purch. Inv. Header"; var PurchRcptLine: Record "Purch. Rcpt. Line"; var PurchaseLine: Record "Purchase Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; TrackingSpecificationExists: Boolean; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; var PurchaseHeader: Record "Purchase Header"; CommitIsSuppressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateInvoicedQtyOnReturnShptLine(PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var ReturnShipmentLine: Record "Return Shipment Line"; PurchaseLine: Record "Purchase Line"; TempTrackingSpecification: Record "Tracking Specification" temporary; TrackingSpecificationExists: Boolean; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateLastPostingNos(var PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdatePurchLineBeforePost(var PurchaseLine: Record "Purchase Line"; WhseShip: Boolean; WhseReceive: Boolean; PurchaseHeader: Record "Purchase Header"; RoundingLineInserted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdatePrepmtPurchLineWithRounding(var PrepmtPurchLine: Record "Purchase Line"; TotalRoundingAmount: array[2] of Decimal; TotalPrepmtAmount: array[2] of Decimal; FinalInvoice: Boolean; PricesInclVATRoundingAmount: array[2] of Decimal; var TotalPurchLine: Record "Purchase Line"; var TotalPurchLineLCY: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdatePurchaseHeader(var VendorLedgerEntry: Record "Vendor Ledger Entry"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; GenJnlLineDocType: Integer; GenJnlLineDocNo: Code[20]; PreviewMode: Boolean; var PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdatePurchLineDimSetIDFromAppliedEntry(var PurchLineToPost: Record "Purchase Line"; PurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterValidatePostingAndDocumentDate(var PurchaseHeader: Record "Purchase Header"; CommitIsSuppressed: Boolean; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeAddAssociatedOrderLineToBuffer(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeModifyTempLine(var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnModifyTempLineOnBeforeTransferFields(var PurchaseLine: Record "Purchase Line"; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeAdjustQuantityRoundingForReceipt(PurchRcptLine: Record "Purch. Rcpt. Line"; RemQtyToInvoiceCurrLine: Decimal; var QtyToBeInvoiced: Decimal; RemQtyToInvoiceCurrLineBase: Decimal; QtyToBeInvoicedBase: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeArchiveUnpostedOrder(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean; var OrderArchived: Boolean; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeArchiveSalesOrders(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeBlanketOrderPurchLineModify(var BlanketOrderPurchLine: Record "Purchase Line"; PurchLine: Record "Purchase Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcInvoice(var PurchHeader: Record "Purchase Header"; var NewInvoice: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalculateAmountsInclVAT(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase 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 OnBeforeCalculateInvoiceEverything(var TempPurchaseLine: Record "Purchase Line" temporary; PurchaseHeader: Record "Purchase Header"; var InvoiceEverything: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCalcLineAmountAndLineDiscountAmount(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; PurchLineQty: Decimal; var IsHandled: Boolean; Currency: Record Currency)    begin    end;#if not CLEAN28    [Obsolete('This event is no longer used.', '28.0')]    [IntegrationEvent(true, false)]    local procedure OnBeforeCheckDropShipmentReceiveInvoice(PurchLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;#endif    [IntegrationEvent(true, false)]    local procedure OnBeforeCheckDocumentTotalAmounts(PurchHeader: Record "Purchase Header"; PreviewMode: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckExternalDocumentNumber(VendorLedgerEntry: Record "Vendor Ledger Entry"; PurchaseHeader: Record "Purchase Header"; var Handled: Boolean; DocType: Option; ExtDocNo: Text[35]; SrcCode: Code[10]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; GenJnlLineDocNo: Code[20]; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var TotalPurchLine: Record "Purchase Line"; var TotalPurchLineLCY: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckExtDocNo(PurchaseHeader: Record "Purchase Header"; DocumentType: Enum "Gen. Journal Document Type"; ExtDocNo: Text[35]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckGLAccDirectPosting(PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckICDocumentDuplicatePosting(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckIfInvPutawayExists(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckHeaderPostingType(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckFieldsOnReturnShipmentLine(var ReturnShipmentLine: Record "Return Shipment Line"; PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckFieldsOnReturnShipmentLine(ReturnShipmentLine: Record "Return Shipment Line"; PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPrepmtAmtToDeduct(PurchaseHeader: Record "Purchase Header"; var TempPurchaseLine: Record "Purchase Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPurchRcptLine(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckTrackingSpecification(PurchHeader: Record "Purchase Header"; var TempItemPurchLine: Record "Purchase Line" temporary);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckTrackingAndWarehouseForShip(PurchHeader: Record "Purchase Header"; var TempPurchLineGlobal: Record "Purchase Line" temporary; var Ship: Boolean; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckWarehouse(var TempItemPurchLine: Record "Purchase Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckWhseRcptLineQtyToReceive(var WhseRcptLine: Record "Warehouse Receipt Line"; var PurchRcptLine: Record "Purch. Rcpt. Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeClearRemAmt(PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean; ItemJnlRollRndg: Boolean; var RemAmt: Decimal; var RemDiscAmt: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreatePositiveEntry(var WarehouseJournalLine: Record "Warehouse Journal Line"; JobNo: Code[20]; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreatePostedWhseRcptHeader(var PostedWhseReceiptHeader: Record "Posted Whse. Receipt Header"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreatePostedWhseShptHeader(var PostedWhseShipmentHeader: Record "Posted Whse. Shipment Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreatePostedWhseShptLine(PurchLine: Record "Purchase Line"; ReturnShptLine: Record "Return Shipment Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreatePostedRcptLine(PurchLine: Record "Purchase Line"; ReturnShptLine: Record "Return Shipment Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateWhseLineFromReturnShptLine(var ReturnShptLine: Record "Return Shipment Line"; PurchLine: Record "Purchase Line"; CostBaseAmount: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCommitAndUpdateAnalysisVeiw(InvtPickPutaway: Boolean; SuppressCommit: Boolean; PreviewMode: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCopyAndCheckItemChargeTempPurchLine(PurchaseHeader: Record "Purchase Header"; var TempPrepmtPurchaseLine: Record "Purchase Line" temporary; var TempItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)" temporary; var IsHandled: Boolean; var AssignError: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreatePrepmtLines(PurchaseHeader: Record "Purchase Header"; var TempPrepmtPurchaseLine: Record "Purchase Line" temporary; CompleteFunctionality: Boolean; var IsHandled: Boolean; var TempPurchLineGlobal: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteAfterPosting(var PurchaseHeader: Record "Purchase Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var SkipDelete: Boolean; CommitIsSupressed: Boolean; var TempPurchLine: Record "Purchase Line" temporary; var TempPurchLineGlobal: Record "Purchase Line" temporary; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteApprovalEntries(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean; PurchInvHeader: Record "Purch. Inv. Header"; PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr.")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeDivideAmount(var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; QtyType: Option General,Invoicing,Shipping; var PurchLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeFinalizePosting(var PurchaseHeader: Record "Purchase Header"; var TempPurchLineGlobal: Record "Purchase Line" temporary; var EverythingInvoiced: Boolean; CommitIsSupressed: Boolean; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetInvoicePostingSetup(var InvoicePostingInterface: Interface "Invoice Posting"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitAssocItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInvoiceRoundingAmount(PurchHeader: Record "Purchase Header"; TotalAmountIncludingVAT: Decimal; UseTempData: Boolean; var InvoiceRoundingAmount: Decimal; CommitIsSupressed: Boolean; var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertICGenJnlLine(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; var ICGenJnlLineNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertPostedHeaders(var PurchaseHeader: Record "Purchase Header"; var WarehouseReceiptHeader: Record "Warehouse Receipt Header"; var WarehouseShipmentHeader: Record "Warehouse Shipment Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertRcptEntryRelation(PurchaseLine: Record "Purchase Line"; var PurchRcptLine: Record "Purch. Rcpt. Line"; var TempHandlingSpecification: Record "Tracking Specification" temporary; TempTrackingSpecificationInv: Record "Tracking Specification" temporary; ItemLedgShptEntryNo: Integer; var Result: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertReceiptHeader(var PurchHeader: Record "Purchase Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var IsHandled: Boolean; CommitIsSuppressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertReceiptLine(var PurchRcptHeader: Record "Purch. Rcpt. Header"; var PurchLine: Record "Purchase Line"; var CostBaseAmount: Decimal; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertReturnShipmentLine(var ReturnShptHeader: Record "Return Shipment Header"; var PurchLine: Record "Purchase Line"; var CostBaseAmount: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertTrackingSpecification(PurchHeader: Record "Purchase Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeItemJnlPostLine(var ItemJournalLine: Record "Item Journal Line"; PurchaseLine: Record "Purchase Line"; PurchaseHeader: Record "Purchase Header"; CommitIsSupressed: Boolean; var IsHandled: Boolean; WhseReceiptHeader: Record "Warehouse Receipt Header"; WhseShipmentHeader: Record "Warehouse Shipment Header"; TempItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)" temporary; TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary; PurchInvHeader: Record "Purch. Inv. Header"; PurchCrMemoHeader: Record "Purch. Cr. Memo Hdr.")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeIsEndLoopForShippedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var ReturnShptLine: Record "Return Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; PurchLine: Record "Purchase Line"; var EndLoop: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeIsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var PurchRcptLine: Record "Purch. Rcpt. Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; PurchLine: Record "Purchase Line"; var EndLoop: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetPurchRcptLineFromTrackingOrUpdateItemEntryRelation(var PurchRcptLine: Record "Purch. Rcpt. Line"; var TrackingSpecification: Record "Tracking Specification"; var ItemEntryRelation: Record "Item Entry Relation"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetPurchLines(var PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeLockTables(var PurchHeader: Record "Purchase Header"; PreviewMode: Boolean; CommitIsSuppressed: Boolean; var IsHandled: Boolean; var TempPurchaseLineGlobal: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostLines(var PurchLine: Record "Purchase Line"; PurchHeader: Record "Purchase Header"; PreviewMode: Boolean; CommitIsSupressed: Boolean; var TempPurchLineGlobal: Record "Purchase Line" temporary; var TempWarehouseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostDistributeItemCharge(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; var TempItemLedgerEntry: Record "Item Ledger Entry"; NonDistrQuantity: Decimal; NonDistrQtyToAssign: Decimal; NonDistrAmountToAssign: Decimal; Sign: Decimal; IndirectCostPct: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostInvoice(var PurchHeader: Record "Purchase Header"; PreviewMode: Boolean; CommitIsSupressed: Boolean; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var IsHandled: Boolean; var Window: Dialog; HideProgressWindow: Boolean; var TotalPurchLine: Record "Purchase Line"; var TotalPurchLineLCY: Record "Purchase Line"; var InvoicePostingInterface: Interface "Invoice Posting"; var InvoicePostingParameters: Record "Invoice Posting Parameters"; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; SrcCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostGLAccICLine(var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var ICGenJnlLineNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemChargePerSalesShpt(var TempItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)"; var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnBeforePostItemJnlLineCopyProdOrder(PurchLine: Record "Purchase Line"; var ItemJnlLine: Record "Item Journal Line"; QtyToBeReceived: Decimal; QtyToBeInvoiced: Decimal; CommitIsSupressed: Boolean; var IsHandled: Boolean)    begin        OnBeforePostItemJnlLineCopyProdOrder(PurchLine, ItemJnlLine, QtyToBeReceived, QtyToBeInvoiced, CommitIsSupressed, IsHandled);    end;    [Obsolete('Moved to codeunit MfgPurchPost', '27.0')]    [IntegrationEvent(true, false)]    local procedure OnBeforePostItemJnlLineCopyProdOrder(PurchLine: Record "Purchase Line"; var ItemJnlLine: Record "Item Journal Line"; QtyToBeReceived: Decimal; QtyToBeInvoiced: Decimal; CommitIsSupressed: Boolean; var IsHandled: Boolean)    begin    end;#endif    [IntegrationEvent(true, false)]    local procedure OnBeforePostPurchaseDoc(var PurchaseHeader: Record "Purchase Header"; PreviewMode: Boolean; CommitIsSupressed: Boolean; var HideProgressWindow: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostCommitPurchaseDoc(var PurchaseHeader: Record "Purchase Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; PreviewMode: Boolean; var ModifyHeader: Boolean; var CommitIsSupressed: Boolean; var TempPurchLineGlobal: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeProcessAssocItemJnlLine(var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempTrackingSpecification: Record "Tracking Specification" temporary; ItemLedgShptEntryNo: Integer; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; SourceCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePrepareCheckDocument(var PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePurchLineDeleteAll(var PurchaseLine: Record "Purchase Line"; CommitIsSupressed: Boolean; var TempPurchLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePurchRcptHeaderInsert(var PurchRcptHeader: Record "Purch. Rcpt. Header"; var PurchaseHeader: Record "Purchase Header"; CommitIsSupressed: Boolean; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; WhseReceive: Boolean; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; WhseShip: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePurchRcptLineInsert(var PurchRcptLine: Record "Purch. Rcpt. Line"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var PurchLine: Record "Purchase Line"; CommitIsSupressed: Boolean; PostedWhseRcptLine: Record "Posted Whse. Receipt Line"; var IsHandled: Boolean; ItemLedgShptEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePurchInvHeaderInsert(var PurchInvHeader: Record "Purch. Inv. Header"; var PurchHeader: Record "Purchase Header"; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePurchInvLineInsert(var PurchInvLine: Record "Purch. Inv. Line"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchaseLine: Record "Purchase Line"; CommitIsSupressed: Boolean; var xPurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePurchCrMemoHeaderInsert(var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var PurchHeader: Record "Purchase Header"; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePurchCrMemoLineInsert(var PurchCrMemoLine: Record "Purch. Cr. Memo Line"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var PurchLine: Record "Purchase Line"; CommitIsSupressed: Boolean; var xPurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeReleasePurchDoc(var PurchHeader: Record "Purchase Header"; PreviewMode: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeReturnShptHeaderInsert(var ReturnShptHeader: Record "Return Shipment Header"; var PurchHeader: Record "Purchase Header"; CommitIsSupressed: Boolean; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; WhseReceive: Boolean; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; WhseShip: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeReturnShptLineInsert(var ReturnShptLine: Record "Return Shipment Line"; var ReturnShptHeader: Record "Return Shipment Header"; var PurchLine: Record "Purchase Line"; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeRoundAmount(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; PurchLineQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSalesShptHeaderInsert(var SalesShptHeader: Record "Sales Shipment Header"; SalesOrderHeader: Record "Sales Header"; CommitIsSupressed: Boolean; var PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSalesShptLineInsert(var SalesShptLine: Record "Sales Shipment Line"; SalesShptHeader: Record "Sales Shipment Header"; SalesLine: Record "Sales Line"; CommitIsSupressed: Boolean; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetCheckApplToItemEntry(var PurchaseLine: Record "Purchase Line"; var Result: Boolean; var IsHandled: Boolean; PurchaseHeader: Record "Purchase Header"; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostCombineSalesOrderShipment(var PurchaseHeader: Record "Purchase Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var SalesShipmentHeader: Record "Sales Shipment Header"; var ItemLedgShptEntryNo: Integer; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempHandlingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemJnlLine(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var QtyToBeReceived: Decimal; var QtyToBeReceivedBase: Decimal; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; var ItemLedgShptEntryNo: Integer; var ItemChargeNo: Code[20]; var TrackingSpecification: Record "Tracking Specification"; CommitIsSupressed: Boolean; var IsHandled: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var Result: Integer; var WarehouseReceiptHeader: Record "Warehouse Receipt Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemJnlLineItemCharges(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostAssocItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var SalesLine: Record "Sales Line"; CommitIsSupressed: Boolean; var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemChargePerOrder(var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var ItemJnlLine2: Record "Item Journal Line"; var ItemChargePurchLine: Record "Purchase Line"; var TempTrackingSpecificationChargeAssmt: Record "Tracking Specification" temporary; CommitIsSupressed: Boolean; var TempItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemChargeLineProcedure(var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemLine(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; PurchRcptHeader: Record "Purch. Rcpt. Header"; var RemQtyToBeInvoiced: Decimal; var TempPurchLineGlobal: Record "Purchase Line" temporary; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var RemQtyToBeInvoicedBase: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostItemJnlLineJobConsumption(var ItemJournalLine: Record "Item Journal Line"; var PurchaseLine: Record "Purchase Line"; PurchInvHeader: Record "Purch. Inv. Header"; PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; SourceCode: Code[10]; var PostJobConsumptionBeforePurch: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostItemTracking(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean; var PreciseTotalChargeAmt: Decimal; var PreciseTotalChargeAmtACY: Decimal; var RoundedPrevTotalChargeAmt: Decimal; var RoundedPrevTotalChargeAmtACY: Decimal; var IsHandled: Boolean; RemQtyToBeInvoiced: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingCheckReceipt(PurchaseLine: Record "Purchase Line"; RemQtyToBeInvoiced: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingCheckShipment(PurchaseLine: Record "Purchase Line"; RemQtyToBeInvoiced: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingForReceiptCondition(PurchaseLine: Record "Purchase Line"; PurchRcptLine: Record "Purch. Rcpt. Line"; var Condition: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingItemChargePerOrder(var TempTrackingSpecificationChargeAssmt: Record "Tracking Specification" temporary; var IsHandled: Boolean; var ItemJnlLine2: Record "Item Journal Line"; var TempTrackingSpecificationChargeAssmtCorrect: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostItemTrackingLineOnPostPurchLine(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean; TempTrackingSpecification: Record "Tracking Specification" temporary; PurchInvHeader: Record "Purch. Inv. Header"; PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingForShipmentCondition(PurchaseLine: Record "Purchase Line"; ReturnShipmentLine: Record "Return Shipment Line"; var Condition: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostResourceLine(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean; SrcCode: Code[10]; GenJnlLineExtDocNo: Code[35]; GenJnlLineDocNo: Code[20]; PurchInvHeader: Record "Purch. Inv. Header"; PurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; JobPurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostUpdateOrderLine(PurchHeader: Record "Purchase Header"; var TempPurchLineGlobal: Record "Purchase Line" temporary; CommitIsSuppressed: Boolean; PurchSetup: Record "Purchases & Payables Setup")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostUpdateOrderLineModifyTempLine(var TempPurchaseLine: Record "Purchase Line" temporary; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeRevertWarehouseEntry(var WarehouseJournalLine: Record "Warehouse Journal Line"; JobNo: Code[20]; PostJobConsumption: Boolean; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSendICDocument(var PurchHeader: Record "Purchase Header"; var ModifyHeader: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeSumPurchLines2(QtyType: Option; var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var VATAmountLine: Record "VAT Amount Line"; InsertPurchLine: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSumPurchLinesTemp(var PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTempDropShptPostBufferInsert(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; PurchaseLine: Record "Purchase Line"; var ItemLedgShptEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTempPrepmtPurchLineInsert(var TempPrepmtPurchLine: Record "Purchase Line" temporary; var TempPurchLine: Record "Purchase Line" temporary; PurchaseHeader: Record "Purchase Header"; CompleteFunctionality: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTempPrepmtPurchLineModify(var TempPrepmtPurchLine: Record "Purchase Line" temporary; var TempPurchLine: Record "Purchase Line" temporary; PurchaseHeader: Record "Purchase Header"; CompleteFunctionality: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTransferReservToItemJnlLine(var SalesOrderLine: Record "Sales Line"; var ItemJnlLine: Record "Item Journal Line"; PurchLine: Record "Purchase Line"; QtyToBeShippedBase: Decimal; var ApplySpecificItemTracking: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeUpdateAssocOrder(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var IsHandled: Boolean; SuppressCommit: Boolean; var PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateBlanketOrderLine(PurchLine: Record "Purchase Line"; Receive: Boolean; Ship: Boolean; Invoice: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdatePostingNos(var PurchHeader: Record "Purchase Header"; var ModifyHeader: Boolean; SuppressCommit: Boolean; var IsHandled: Boolean; var DateOrderSeriesUsed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdatePurchaseHeader(var VendorLedgerEntry: Record "Vendor Ledger Entry"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; GenJnlLineDocType: Option; var IsHandled: Boolean; var PurchaseHeader: Record "Purchase Header"; GenJnlLineDocNo: Code[20]; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdatePurchLineBeforePost(var PurchaseLine: Record "Purchase Line"; var PurchaseHeader: Record "Purchase Header"; WhseShip: Boolean; WhseReceive: Boolean; RoundingLineInserted: Boolean; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateInvoicedQtyOnPurchRcptLine(var PurchRcptLine: Record "Purch. Rcpt. Line"; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; CommitIsSupressed: Boolean; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdatePrepmtPurchLineWithRounding(var PrepmtPurchLine: Record "Purchase Line"; TotalRoundingAmount: array[2] of Decimal; TotalPrepmtAmount: array[2] of Decimal; FinalInvoice: Boolean; PricesInclVATRoundingAmount: array[2] of Decimal; var TotalPurchLine: Record "Purchase Line"; var TotalPurchLineLCY: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateQtyToInvoiceForOrder(var PurchHeader: Record "Purchase Header"; TempPurchLine: Record "Purchase Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateQtyToInvoiceForReturnOrder(var PurchHeader: Record "Purchase Header"; TempPurchLine: Record "Purchase Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateQtyToBeInvoicedForReceipt(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; PurchLine: Record "Purchase Line"; PurchRcptLine: Record "Purch. Rcpt. Line"; InvoicingTrackingSpecification: Record "Tracking Specification"; RemQtyToBeInvoiced: Decimal; RemQtyToBeInvoicedBase: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateQtyToBeInvoicedForReturnShipment(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; PurchLine: Record "Purchase Line"; ReturnShipmentLine: Record "Return Shipment Line"; InvoicingTrackingSpecification: Record "Tracking Specification"; RemQtyToBeInvoiced: Decimal; RemQtyToBeInvoicedBase: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateJobConsumptionReservationApplToItemEntry(var TempReservEntryJobCons: Record "Reservation Entry" temporary; var ItemJournalLine: Record "Item Journal Line"; IsNonInventoriableItem: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTestPurchLine(var PurchaseLine: Record "Purchase Line"; var PurchaseHeader: Record "Purchase Header"; CommitIsSupressed: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTestPurchLineFixedAsset(PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTestPurchLineItemCharge(PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTestPurchLineJob(PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTestPurchLineOthers(PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTestStatusRelease(PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateItemChargeAssgnt(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateHandledICInboxTransaction(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeValidatePostingAndDocumentDate(var PurchaseHeader: Record "Purchase Header"; CommitIsSupressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValidatePostingAndDocumentDateOnSetPostingDateExists(var PurchaseHeader: Record "Purchase Header"; CommitIsSupressed: Boolean; var PostingDateExists: Boolean; var ReplacePostingDate: Boolean; var PostingDate: Date; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeWhseHandlingRequired(PurchaseLine: Record "Purchase Line"; var Required: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetCountryCode(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var CountryRegionCode: Code[10]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeShouldPostWhseJnlLine(PurchLine: Record "Purchase Line"; var Result: Boolean; var IsHandled: Boolean; var ItemJnlLine: Record "Item Journal Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; WhseReceive: Boolean; WhseShip: Boolean; InvtPickPutaway: Boolean; SrcCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcInvDiscountSetFilter(var PurchLine: Record "Purchase Line"; PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnAfterClearPostingFromWhseRef(var PurchHeader: Record "Purchase Header"; var InvtPickPutaway: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnAfterSetPostingFlags(var PurchHeader: Record "Purchase Header"; var TempPurchLineGlobal: Record "Purchase Line" temporary);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnBeforeSetPostingFlags(var PurchHeader: Record "Purchase Header"; var TempPurchLineGlobal: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnAfterSetSourceCode(var PurchHeader: Record "Purchase Header"; SourceCodeSetup: Record "Source Code Setup"; var SrcCode: Code[10]);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnAfterArchiveUnpostedOrder(var PurchHeader: Record "Purchase Header"; Currency: Record "Currency"; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnBeforeCalcInvDiscount(var PurchaseHeader: Record "Purchase 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 OnCheckAndUpdateAssocOrderPostingDateOnBeforeValidateDocumentDate(var SalesHeader: Record "Sales Header"; var OriginalDocumentDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAssociatedOrderLinesOnAfterSetFilters(var PurchaseLine: Record "Purchase Line"; PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAssociatedOrderLinesOnAfterCheckDimensions(PurchaseHeader: Record "Purchase Header"; SalesHeader: Record "Sales Header"; var PurchaseLine: Record "Purchase Line"; TempSalesLine: Record "Sales Line" temporary)    begin    end;#if not CLEAN28    [Obsolete('This event is no longer used.', '28.0')]    [IntegrationEvent(false, false)]    local procedure OnCheckAssocOrderLinesOnBeforeCheckOrderLine(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean; SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnCheckExternalDocumentNumberOnAfterSetFilters(var VendLedgEntry: Record "Vendor Ledger Entry"; PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckTrackingAndWarehouseForShipOnAfterTempPurchLineSetFilters(PurchaseHeader: Record "Purchase Header"; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckTrackingAndWarehouseForReceiveOnAfterTempPurchLineSetFilters(PurchaseHeader: Record "Purchase Header"; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckWarehouseOnAfterSetFilters(var TempItemPurchLine: Record "Purchase Line");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCopyAndCheckItemChargeOnBeforeLoop(var TempPurchLine: Record "Purchase Line" temporary; PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCopyAndCheckItemChargeOnBeforeCheckIfEmpty(var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCopyToTempLinesOnAfterSetFilters(var PurchaseLine: Record "Purchase Line"; PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepmtLinesOnAfterInitTempPrepmtPurchLineFromPurchHeader(var TempPrepmtPurchLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepmtLinesOnAfterTempPurchLineSetFilters(var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepmtLinesOnAfterTempPrepmtPurchLineSetFilters(var TempPrepmtPurchLine: Record "Purchase Line" temporary; var TempPurchLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnAfterClearAmounts(var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var PurchLineQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnAfterCalcLineAmountAndLineDiscountAmount(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; PurchaseLineQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnBeforeTempVATAmountLineRemainderModify(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase 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 OnGetItemChargeLineOnAfterGet(var ItemChargePurchLine: Record "Purchase Line"; PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetPurchLinesOnAfterFillTempLines(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; QtyType: Option; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertICGenJnlLineOnAfterCopyDocumentFields(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; var TempICGenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertAssocOrderChargeOnBeforeInsert(TempItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)"; var NewItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertICGenJnlLineOnBeforeICGenJnlLineInsert(var TempICGenJournalLine: Record "Gen. Journal Line" temporary; PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; CommitIsSuppressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertReceiptLineOnAfterGetWhseRcptLine(var WhseRcptLine: Record "Warehouse Receipt Line"; PurchRcptLine: Record "Purch. Rcpt. Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertReceiptLineOnAfterInitPurchRcptLine(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchLine: Record "Purchase Line"; ItemLedgShptEntryNo: Integer; xPurchLine: Record "Purchase Line"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var CostBaseAmount: Decimal; PostedWhseRcptHeader: Record "Posted Whse. Receipt Header"; WhseRcptHeader: Record "Warehouse Receipt Header"; var WhseRcptLine: Record "Warehouse Receipt Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertReceiptLineOnAfterCalcShouldGetWhseRcptLine(PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchLine: Record "Purchase Line"; PostedWhseRcptHeader: Record "Posted Whse. Receipt Header"; WhseRcptHeader: Record "Warehouse Receipt Header"; CostBaseAmount: Decimal; WhseReceive: Boolean; WhseShip: Boolean; var ShouldGetWhseRcptLine: Boolean; xPurchLine: Record "Purchase Line"; var PurchRcptLine: Record "Purch. Rcpt. Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertReceiptLineOnAfterCalcShouldGetWhseShptLine(PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchLine: Record "Purchase Line"; PostedWhseShptHeader: Record "Posted Whse. Shipment Header"; WhseShptHeader: Record "Warehouse Shipment Header"; CostBaseAmount: Decimal; WhseReceive: Boolean; WhseShip: Boolean; var ShouldGetWhseShptLine: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertReturnShipmentLineOnAfterGetWhseShptLine(var WhseShptLine: Record "Warehouse Shipment Line"; ReturnShptLine: Record "Return Shipment Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertReturnShipmentLineOnAfterReturnShptLineInit(var ReturnShptHeader: Record "Return Shipment Header"; var ReturnShptLine: Record "Return Shipment Line"; var PurchLine: Record "Purchase Line"; var xPurchLine: Record "Purchase Line"; var CostBaseAmount: Decimal; WhseShip: Boolean; WhseReceive: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostAssocItemJnlLineOnBeforePost(var ItemJournalLine: Record "Item Journal Line"; SalesOrderLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCombineSalesOrderShipmentOnAfterUpdateBlanketOrderLine(var PurchaseHeader: Record "Purchase Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer"; var SalesOrderLine: Record "Sales Line"; var SalesOrderHeader: record "Sales Header"; var SalesShptLine: record "Sales Shipment Line"; SalesShptHeader: Record "Sales Shipment Header"; SrcCode: Code[10]; Currency: Record Currency)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCombineSalesOrderShipmentOnBeforeUpdateBlanketOrderLine(var SalesOrderLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCombineSalesOrderShipmentOnAfterProcessDropShptPostBuffer(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; PurchRcptHeader: Record "Purch. Rcpt. Header"; SalesShptLine: Record "Sales Shipment Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDistributeItemChargeOnAfterCalcAmountToAssign(var PurchaseLine: Record "Purchase Line"; TempItemLedgerEntry: Record "Item Ledger Entry"; QtyToAssign: Decimal; AmountToAssign: Decimal; Sign: Decimal; Factor: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostItemChargeOnAfterPostItemJnlLine(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; ItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostItemChargeLineOnAfterPostItemCharge(var TempItemChargeAssgntPurch: record "Item Charge Assignment (Purch)" temporary; PurchHeader: Record "Purchase Header"; PurchaseLineBackup: Record "Purchase Line"; PurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargeLineOnBeforePostItemCharge(var TempItemChargeAssgntPurch: record "Item Charge Assignment (Purch)" temporary; PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; var GenJnlLineDocNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargeOnBeforePostItemJnlLine(var PurchaseLineToPost: Record "Purchase Line"; var PurchaseLine: Record "Purchase Line"; QtyToAssign: Decimal; var TempItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)" temporary; PurchInvHeader: Record "Purch. Inv. Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerOrderOnAfterCopyToItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var PurchaseLine: Record "Purchase Line"; GeneralLedgerSetup: Record "General Ledger Setup"; QtyToInvoice: Decimal; var TempItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)" temporary; PurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerRetRcptOnAfterCalcDistributeCharge(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var ReturnRcptLine: Record "Return Receipt Line"; var TempItemLedgEntry: Record "Item Ledger Entry" temporary; var DistributeCharge: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerSalesRetRcptOnBeforeTestJobNo(ReturnReceiptLine: Record "Return Receipt Line"; var IsHandled: Boolean; var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerSalesShptOnAfterCalcDistributeCharge(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var SalesShptLine: Record "Sales Shipment Line"; var TempItemLedgEntry: Record "Item Ledger Entry" temporary; var DistributeCharge: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerSalesShptOnBeforeTestJobNo(SalesShipmentLine: Record "Sales Shipment Line"; var IsHandled: Boolean; var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerRetShptOnAfterCalcDistributeCharge(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var ReturnShptLine: Record "Return Shipment Line"; var TempItemLedgEntry: Record "Item Ledger Entry" temporary; var DistributeCharge: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerRetShptOnBeforeTestJobNo(ReturnShipmentLine: Record "Return Shipment Line"; var IsHandled: Boolean; var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerRcptOnAfterCalcDistributeCharge(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; var PurchRcptLine: record "Purch. Rcpt. Line"; var TempItemLedgEntry: Record "Item Ledger Entry" temporary; var DistributeCharge: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerRcptOnAfterPurchRcptLineGet(PurchRcptLine: Record "Purch. Rcpt. Line"; var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerTransferOnAfterInitPurchLine2(TransferReceiptLine: Record "Transfer Receipt Line"; var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerTransferOnBeforePostItemJnlLine(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; ItemApplnEntry: Record "Item Application Entry"; TransferReceiptLine: Record "Transfer Receipt Line"; ItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerITTransferOnAfterCollectItemEntryRelation(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; TransRcptLine: Record "Transfer Receipt Line"; var TempItemLedgEntry: Record "Item Ledger Entry" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineWhseLineOnBeforeTempWhseJnlLine2Find(var TempWarehouseJournalLine2: Record "Warehouse Journal Line" temporary; PurchaseLine: Record "Purchase Line"; WhseReceive: Boolean; WhseShip: Boolean; InvtPickPutaway: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterCopyDocumentFields(var ItemJournalLine: Record "Item Journal Line"; PurchaseLine: Record "Purchase Line"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; PurchRcptHeader: Record "Purch. Rcpt. Header"; GenJnlLineExtDocNo: Code[35]; QtyToBeInvoiced: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnBeforePostItemJnlLineCopyDocumentFields(var ItemJournalLine: Record "Item Journal Line"; PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; QtyToBeInvoiced: Decimal; QtyToBeReceived: Decimal; WhseReceive: Boolean; WhseShip: Boolean; InvtPickPutaway: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterPostItemJnlLineJobConsumption(var ItemJournalLine: Record "Item Journal Line"; PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; OriginalItemJnlLine: Record "Item Journal Line"; var TempReservationEntry: Record "Reservation Entry" temporary; var TrackingSpecification: Record "Tracking Specification" temporary; QtyToBeInvoiced: Decimal; QtyToBeReceived: Decimal; var PostJobConsumptionBeforePurch: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostItemJnlLineOnAfterCopyItemCharge(var ItemJournalLine: Record "Item Journal Line"; var TempItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnBeforeCopyDocumentFields(var ItemJournalLine: Record "Item Journal Line"; PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; WhseReceive: Boolean; WhseShip: Boolean; InvtPickPutaway: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnBeforePostWhseJnlLine(TempHandlingSpecification: Record "Tracking Specification"; var TempWhseJnlLine: Record "Warehouse Journal Line"; ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostItemJnlLineJobConsumptionOnBeforeRunItemJnlPostLineWithReservation(var ItemJournalLine: Record "Item Journal Line"; var TempReservationEntry: Record "Reservation Entry" temporary; var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineJobConsumption(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; ItemJournalLine: Record "Item Journal Line"; var TempPurchReservEntry: Record "Reservation Entry" temporary; QtyToBeInvoiced: Decimal; QtyToBeReceived: Decimal; var TempTrackingSpecification: Record "Tracking Specification" temporary; PurchItemLedgEntryNo: Integer; var IsHandled: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; SrcCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterSetFactor(var PurchaseLine: Record "Purchase Line"; var Factor: Decimal; var GenJnlLineExtDocNo: Code[35]; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterPrepareItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; PurchaseLine: Record "Purchase Line"; PurchaseHeader: Record "Purchase Header"; PreviewMode: Boolean; var GenJnlLineDocNo: code[20]; TrackingSpecification: Record "Tracking Specification"; QtyToBeReceived: Decimal; QtyToBeInvoiced: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnCopyProdOrder(var ItemJournalLine: Record "Item Journal Line"; PurchaseLine: Record "Purchase Line"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; QtyToBeReceived: Decimal; QtyToBeInvoiced: Decimal; SuppressCommit: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineJobConsumptionOnBeforeJobPost(        var PurchaseHeader: Record "Purchase Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHeader: Record "Purch. Cr. Memo Hdr.";        var PurchRcptHeader: Record "Purch. Rcpt. Header"; var ReturnShptHeader: Record "Return Shipment Header"; PurchaseLine: Record "Purchase Line";        SrcCode: Code[10]; QtyToBeReceived: Decimal; var IsHandled: Boolean; QtyToBeInvoiced: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineJobConsumptionOnBeforePrepareJobLine(var PurchaseLine: Record "Purchase Line"; QuantityToBeInvoiced: Decimal; var PurchaseHeader: Record "Purchase Header"; var PurchaseLineACY: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineWhseLineOnAfterPostRevert(var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineWhseLineOnBeforePostSingleLine(WhseShip: Boolean; WhseReceive: Boolean; InvtPickPutaway: Boolean; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterItemJnlPostLineRunWithCheck(var ItemJnlLine: Record "Item Journal Line"; var PurchaseLine: Record "Purchase Line"; var PurchaseHeader: Record "Purchase Header"; QtyToBeReceived: Decimal; WhseReceive: Boolean; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; QtyToBeReceivedBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnBeforeItemJnlPostLineRunWithCheck(var ItemJnlLine: Record "Item Journal Line"; var PurchaseLine: Record "Purchase Line"; DropShipOrder: Boolean; PurchaseHeader: Record "Purchase Header"; WhseReceive: Boolean; QtyToBeReceived: Decimal; QtyToBeReceivedBase: Decimal; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnBeforeInitAmount(var ItemJnlLine: Record "Item Journal Line"; PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineItemChargesOnAfterGetItemChargeLine(var ItemChargePurchaseLine: Record "Purchase Line"; PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemLineOnBeforePostShipReceive(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForReceiptOnBeforeReceiptInvoiceErr(PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForReceiptOnBeforePostItemTrackingForReceiptCondition(var PurchInvHeader: Record "Purch. Inv. Header"; var PurchRcptLine: Record "Purch. Rcpt. Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForReceiptOnAfterPurchRcptLineTestFields(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForReceiptOnAfterPurchRcptLineSetFilters(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchaseLine: Record "Purchase Line"; PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForShipmentOnBeforeReturnShipmentInvoiceErr(PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnAfterSetEverythingInvoiced(var PurchaseLine: Record "Purchase Line"; var EverythingInvoiced: Boolean; PurchaseHeader: Record "Purchase Header"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; var AmountsOnly: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnAfterPostByType(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; SrcCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCollectPurchaseLineReservEntries(var JobReservationEntry: Record "Reservation Entry"; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetPurchOrderLine(var PurchaseLineOrder: Record "Purchase Line"; PurchaseLine: Record "Purchase Line"; PurchRcptLine: Record "Purch. Rcpt. Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostPurchLineOnBeforePostByType(PurchHeader: Record "Purchase Header"; PurchInvHeader: Record "Purch. Inv. Header"; PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; PurchLine: Record "Purchase Line"; PurchLineACY: Record "Purchase Line"; Sourcecode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnBeforeInsertCrMemoLine(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean; var PurchCrMemoLine: Record "Purch. Cr. Memo Line"; xPurchaseLine: Record "Purchase Line");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnBeforeInsertInvoiceLine(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean; var PurchInvLine: Record "Purch. Inv. Line");    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostPurchLineOnBeforeInsertReceiptLine(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean; PurchRcptHeader: Record "Purch. Rcpt. Header"; RoundingLineInserted: Boolean; CostBaseAmount: Decimal; xPurchaseLine: Record "Purchase Line"; var ReturnShipmentHeader: Record "Return Shipment Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var ItemLedgShptEntryNo: Integer; SrcCode: Code[10]; PreviewMode: Boolean; var WarehouseReceiptHeader: Record "Warehouse Receipt Header"; WhseReceive: Boolean; WhseShip: Boolean; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; GenJnlLineDocNo: Code[20]);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnBeforeInsertReturnShipmentLine(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean; ReturnShptHeader: Record "Return Shipment Header"; TempPurchLineGlobal: Record "Purchase Line"; RoundingLineInserted: Boolean; xPurchaseLine: Record "Purchase Line"; var PurchRcptHeader: Record "Purch. Rcpt. Header");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnBeforeRoundAmount(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; SrcCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnTypeCaseElse(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; PurchInvHeader: Record "Purch. Inv. Header"; PurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; SourceCode: Code[10]; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnAfterCreatePostedDeferralScheduleFromPurchDoc(var PurchInvLine: Record "Purch. Inv. Line"; PurchInvHeader: Record "Purch. Inv. Header"; PurchLine: Record "Purchase Line"; ItemLedgShptEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSupressed: Boolean; xPurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnAfterCreatePostedDeferralScheduleFromPurchDocCrMemo(var PurchCrMemoLine: Record "Purch. Cr. Memo Line"; PurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; PurchLine: Record "Purchase Line"; ItemLedgShptEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSupressed: Boolean; xPurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateCreditMemoLineOnAfterPurchOrderLineModify(var PurchaseLine: Record "Purchase Line"; var TempPurchaseLine: Record "Purchase Line" temporary; var ReturnShptLine: Record "Return Shipment Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateCreditMemoLineOnAfterResetTempLines(var TempPurchLine: Record "Purchase Line" temporary; var IsHandled: Boolean; var PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateCreditMemoLineOnBeforeInitQtyToInvoice(var PurchaseLine: Record "Purchase Line"; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnAfterPurchOrderLineGet(var TempPurchLine: Record "Purchase Line" temporary; PurchRcptLine: Record "Purch. Rcpt. Line"; PurchOrderLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnAfterPurchOrderLineModify(var PurchaseLine: Record "Purchase Line"; var TempPurchaseLine: Record "Purchase Line" temporary; var PurchOrderLine: Record "Purchase Line"; var TempPurchLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnBeforeInitQtyToInvoice(var PurchaseLine: Record "Purchase Line"; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnAfterInitQtyToReceiveOrShip(var PurchaseHeader: Record "Purchase Header"; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeUpdateBlanketOrderLine(var PurchaseHeader: Record "Purchase Header"; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeInitOutstanding(var PurchaseHeader: Record "Purchase Header"; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeInitQtyToInvoice(var TempPurchaseLine: Record "Purchase Line" temporary; WhseShip: Boolean; WhseReceive: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeLoop(PurchHeader: Record "Purchase Header"; var TempPurchLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnPurchHeaderReceive(var TempPurchLine: Record "Purchase Line"; PurchRcptHeader: Record "Purch. Rcpt. Header")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostUpdateOrderLineOnSetDefaultQtyBlank(var PurchaseHeader: Record "Purchase Header"; var TempPurchaseLine: Record "Purchase Line" temporary; PurchPost: Record "Purchases & Payables Setup"; var SetDefaultQtyBlank: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnProcessAssocItemJnlLineOnAfterInitTempDropShptPostBuffer(var PurchLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnReleasePurchDocumentOnBeforeSetStatus(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRoundAmountOnBeforeCalculateLCYAmounts(var xPurchLine: Record "Purchase Line"; var PurchLineACY: Record "Purchase Line"; PurchHeader: Record "Purchase Header"; var IsHandled: Boolean; TotalPurchaseLine: Record "Purchase Line"; TotalPurchaseLineLCY: Record "Purchase Line"; var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRoundAmountOnBeforeIncrAmount(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; PurchLineQty: Decimal; var TotalPurchLine: Record "Purchase Line"; var TotalPurchLineLCY: Record "Purchase Line"; var xPurchaseLine: Record "Purchase Line"; var CurrExchRate: Record "Currency Exchange Rate"; var NoVAT: Boolean; var IsHandled: Boolean; var NonDeductibleVAT: Codeunit "Non-Deductible VAT")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforeFinalizePosting(var PurchaseHeader: Record "Purchase Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var ReturnShipmentHeader: Record "Return Shipment Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; CommitIsSuppressed: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforeMakeInventoryAdjustment(var PurchaseHeader: Record "Purchase Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; PreviewMode: Boolean; PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchInvHeader: Record "Purch. Inv. Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSumPurchLines2OnAfterSetFilters(var PurchaseLine: Record "Purchase Line"; PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSumPurchLines2OnAfterDivideAmount(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; QtyType: Option General,Invoicing,Shipping; PurchLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSumPurchLines2OnBeforeDivideAmount(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; QtyType: Option General,Invoicing,Shipping; var PurchLineQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssocOrderOnAfterSalesOrderHeaderModify(var SalesOrderHeader: Record "Sales Header"; var SalesSetup: Record "Sales & Receivables Setup")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssociatedSalesOrderOnBeforeClearTempDropShptPostBuffer(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssocOrderOnAfterSalesOrderLineModify(var SalesOrderLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; SalesOrderHeader: Record "Sales Header"; SalesShptHeader: Record "Sales Shipment Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssocOrderOnAfterOrderNoClearFilter(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssocOrderOnBeforeSalesOrderLineModify(var SalesOrderLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; SalesOrderHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateBlanketOrderLineOnBeforeCheck(var BlanketOrderPurchLine: Record "Purchase Line"; PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean; Ship: Boolean; Receive: Boolean; Invoice: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateBlanketOrderLineOnBeforeInitOutstanding(var BlanketOrderPurchaseLine: Record "Purchase Line"; PurchaseLine: Record "Purchase Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateBlanketOrderLineOnAfterCheckBlanketOrderPurchLine(var BlanketOrderPurchaseLine: Record "Purchase Line"; PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdatePurchLineBeforePostOnAfterCalcInitQtyToInvoiceNeeded(var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var InitQtyToInvoiceNeeded: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateWhseDocumentsOnAfterUpdateWhseRcpt(var WarehouseReceiptHeader: Record "Warehouse Receipt Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateWhseDocumentsOnAfterUpdateWhseShpt(var WarehouseShipmentHeader: Record "Warehouse Shipment Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeRunItemJnlPostLineWithReservation(var ItemJournalLine: Record "Item Journal Line");    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCheckAndUpdateOnAfterCopyAndCheckItemCharge(var PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCheckAndUpdateOnAfterCalcCopyAndCheckItemChargeNeeded(var PurchHeader: Record "Purchase Header"; var CopyAndCheckItemChargeNeeded: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdatePostingNosOnBeforeUpdatePostingNo(PurchHeader: Record "Purchase Header"; PreviewMode: Boolean; var ModifyHeader: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdatePostingNosOnAfterCalcShouldUpdateReceivingNo(PurchaseHeader: Record "Purchase Header"; PreviewMode: Boolean; var ModifyHeader: Boolean; var ShouldUpdateReceivingNo: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePositiveOnBeforeWhseJnlPostLine(var WhseJnlLine: Record "Warehouse Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePostedWhseShptLineOnBeforeCreatePostedShptLine(var ReturnShipmentLine: Record "Return Shipment Line"; var WarehouseShipmentLine: Record "Warehouse Shipment Line"; PostedWhseShipmentHeader: Record "Posted Whse. Shipment Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePostedRcptLineOnBeforeCreatePostedRcptLine(var ReturnShipmentLine: Record "Return Shipment Line"; var WarehouseReceiptLine: Record "Warehouse Receipt Line"; PostedWhseReceiptHeader: Record "Posted Whse. Receipt Header")    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 OnSaveInvoiceSpecificationOnBeforeTempTrackingSpecificationModify(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 OnBeforePostUpdateInvoiceLine(var TempPurchLine: Record "Purchase Line" temporary; var IsHandled: Boolean; var PurchaseHeader: Record "Purchase Header")    begin    end;#if not CLEAN28    [Obsolete('This event is no longer used.', '28.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckAssociatedSalesOrderLine(PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckAssociatedOrderLines(var PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckReceiveInvoiceShip(var PurchHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingItemChargePerOrderOnAfterCalcFactor(var NonDistrItemJnlLine: Record "Item Journal Line"; var ItemJnlLine2: Record "Item Journal Line"; var TempTrackingSpecificationChargeAssmt: Record "Tracking Specification"; SignFactor: Integer; Factor: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingItemChargePerOrderOnAfterUpdateItemJnlLine2LocationCode(var ItemJnlLine2: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForShipmentOnAfterReturnShptLineReset(var ReturnShptLine: Record "Return Shipment Line"; PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForShipmentOnBeforeSetItemEntryRelationForShipment(var ItemEntryRelation: Record "Item Entry Relation"; var ReturnShptLine: Record "Return Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingForShipmentOnBeforeAdjustQuantityRounding(ReturnShptLine: Record "Return Shipment Line"; RemQtyToInvoiceCurrLine: Decimal; var QtyToBeInvoiced: Decimal; RemQtyToInvoiceCurrLineBase: Decimal; QtyToBeInvoicedBase: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnRunOnAfterFillTempLines(var PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnRunOnAfterInvoiceRounding(var PurchHeader: Record "Purchase Header"; var TempPurchLineGlobal: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnRunOnBeforeFillTempLines(PreviewMode: Boolean; var GenJnlLineDocNo: Code[20])    begin    end;    [IntegrationEvent(true, false)]    local procedure OnRunOnAfterPostPurchLine(var TempPurchLineGlobal: Record "Purchase Line" temporary; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var ReturnShipmentHeader: Record "Return Shipment Header")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterCalcInvDiscount(PurchHeader: Record "Purchase Header"; var TempPurchLineGlobal: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostGLAccICLineOnBeforeCheckAndInsertICGenJnlLine(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; xPurchaseLine: Record "Purchase Line"; ICGenJnlLineNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostGLAccICLineOnAfterCreateJobPurchLine(var PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostItemJnlLineTrackingOnBeforeTempHandlingSpecificationFind(PurchLine: Record "Purchase Line"; var TempHandlingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnFinalizePostingOnAfterUpdateItemChargeAssgnt(var PurchHeader: Record "Purchase Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var EverythingInvoiced: Boolean; var TempPurchLine: Record "Purchase Line" temporary; var TempPurchLineGlobal: Record "Purchase Line" temporary; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnFinalizePostingOnBeforeInsertValueEntryRelation(var PurchHeader: Record "Purchase Header"; PurchInvHeader: Record "Purch. Inv. Header"; PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr.")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnFinalizePostingOnBeforeInsertTrackingSpecification(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; PurchHeader: Record "Purchase Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary; EverythingInvoiced: Boolean; var TempPurchLine: Record "Purchase Line"; var TempPurchLineGlobal: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnFinalizePostingOnBeforeUpdateWhseDocuments(var PurchaseHeader: Record "Purchase Header"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary;        WarehouseShipmentHeader: Record "Warehouse Shipment Header"; TempWarehouseShipmentHeader: Record "Warehouse Shipment Header" temporary; WarehouseReceive: Boolean; WarehouseShip: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnFinalizePostingOnBeforeCommit(PreviewMode: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertReceiptLineOnBeforeCreatePostedRcptLine(var PurchRcptLine: Record "Purch. Rcpt. Line"; var WarehouseReceiptLine: Record "Warehouse Receipt Line"; PostedWhseReceiptHeader: Record "Posted Whse. Receipt Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertReceiptLineOnBeforeCreatePostedShptLine(var PurchRcptLine: Record "Purch. Rcpt. Line"; var WarehouseShipmentLine: Record "Warehouse Shipment Line"; PostedWhseShipmentHeader: Record "Posted Whse. Shipment Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertReceiptLineOnBeforeProcessWhseShptRcpt(var PurchLine: Record "Purchase Line"; var IsHandled: Boolean; var CostBaseAmount: Decimal; PurchRcptLine: Record "Purch. Rcpt. Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnBeforeArchiveUnpostedOrder(var PurchHeader: Record "Purchase Header"; PreviewMode: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnAfterInsertPostedHeaders(var PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssosOrderPostingNosOnBeforeReleaseSalesHeader(var PurchHeader: Record "Purchase Header"; var SalesOrderHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssosOrderPostingNosOnAfterReleaseSalesHeader(var PurchHeader: Record "Purchase Header"; var SalesOrderHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdatePostingNosOnAfterSetReturnShipmentNoFromNos(var PurchHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdatePostingNosOnInvoiceOnBeforeSetPostingNo(var PurchHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValidatePostingAndDocumentDateOnAfterCalcPostingDateExists(var PurchHeader: Record "Purchase Header"; var PostingDateExists: Boolean; var ReplacePostingDate: Boolean; var PostingDate: Date; var ReplaceDocumentDate: Boolean; var ModifyHeader: Boolean; var VATDateExists: Boolean; var ReplaceVATDate: Boolean; var VATDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnNeedUpdateGenProdPostingGroupOnItemChargeOnPurchaseLine(PurchaseLine: Record "Purchase Line"; var NeedUpdate: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnNeedUpdateGenProdPostingGroupOnItemChargeOnPurchRcptLine(PurchRcptLine: Record "Purch. Rcpt. Line"; var NeedUpdate: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnNeedUpdateGenProdPostingGroupOnItemChargeOnReturnShipmentLine(ReturnShipmentLine: Record "Return Shipment Line"; var NeedUpdate: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertReturnShipmentHeader(var PurchHeader: Record "Purchase Header"; var ReturnShptHeader: Record "Return Shipment Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertInvoiceHeader(var PurchHeader: Record "Purchase Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var IsHandled: Boolean; var Window: Dialog; var HideProgressWindow: Boolean; var SrcCode: Code[10]; var PurchCommentLine: Record "Purch. Comment Line"; var RecordLinkManagement: Codeunit "Record Link Management")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInserCrMemoHeader(var PurchHeader: Record "Purchase Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var HideProgressWindow: Boolean; var Window: Dialog; var IsHandled: Boolean; SrcCode: Code[10]; PurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; var PurchCommentLine: Record "Purch. Comment Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCombineSalesOrderShipmentOnBeforeCopyComments(var PurchHeader: Record "Purchase Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var SalesShptHeader: Record "Sales Shipment Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostInvoiceOnBeforePostBalancingEntry(var PurchHeader: Record "Purchase Header"; var LineCount: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnAfterReceive(var PurchHeader: Record "Purchase Header"; var TempPurchLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateAssosOrderPostingNos(var TempPurchLine: Record "Purchase Line" temporary; var PurchHeader: Record "Purchase Header"; var DropShipment: Boolean; var IsHandled: Boolean; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnFinalizePostingOnBeforeUpdateAfterPosting(var PurchHeader: Record "Purchase Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var EverythingInvoiced: Boolean; var IsHandled: Boolean; var TempPurchLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnBeforePurchOrderLineModify(var PurchOrderLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostPurchLine(var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateOrderLineOnBeforeFindTempPurchLine(var TempPurchaseLine: Record "Purchase Line"; var PurchaseHeader: Record "Purchase Header");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcInvoiceOnAfterResetTempLines(var PurchHeader: Record "Purchase Header"; var TempPurchLine: Record "Purchase Line" temporary; var NewInvoice: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnAfterPostInvoice(var PurchaseHeader: Record "Purchase Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var ReturnShipmentHeader: Record "Return Shipment Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var PreviewMode: Boolean; var Window: Dialog; SrcCode: Code[10]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; GenJnlLineDocNo: Code[20]; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCopyToTempLinesLoop(var PurchLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforePostPurchLine(var PurchLine: Record "Purchase Line"; var PurchHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeValidateICPartnerBusPostingGroups(var TempICGenJnlLine: Record "Gen. Journal Line" temporary; PurchaseLine: Record "Purchase 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 OnCreatePrepaymentLinesOnBeforeInsertedPrepmtVATBaseToDeduct(var TempPrepmtPurchLine: Record "Purchase Line" temporary; var PurchaseHeader: Record "Purchase Header"; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnAfterGetPurchPrepmtAccount(var GLAcc: Record "G/L Account"; var TempPurchaseLine: Record "Purchase Line" temporary; PurchaseHeader: Record "Purchase Header"; CompleteFunctionality: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnBeforeGetPurchPrepmtAccount(var GLAcc: Record "G/L Account"; var TempPurchaseLine: Record "Purchase Line" temporary; PurchaseHeader: Record "Purchase Header"; var GenPostingSetup: Record "General Posting Setup"; CompleteFunctionality: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertReturnEntryRelation(var ReturnShptLine: Record "Return Shipment Line"; var Result: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnTestPurchLineOnBeforeTestFieldQtyToReceive(var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnTestPurchLineOnBeforeTestFieldReturnQtyToShip(var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnAfterCalcVATAmountLines(var PurchaseHeader: Record "Purchase Header"; var TempPurchLineGlobal: Record "Purchase Line" temporary; var TempVATAmountLine: Record "VAT Amount Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostAssocItemJnlLineOnBeforeInitAssocItemJnlLine(var SalesOrderLine: Record "Sales Line"; var ItemShptEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckTrackingSpecificationOnBeforeGetItemTrackingSetup(var PurchaseLine: Record "Purchase Line"; var ItemTrackingSetup: Record "Item Tracking Setup"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcItemJnlLineToBeReceivedAmounts(var ItemJnlLine: Record "Item Journal Line"; var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; QtyToBeReceived: Decimal; var RemAmt: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostAssocItemJnlLineOnBeforeExit(SalesOrderHeader: Record "Sales Header"; var ItemShptEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateInvoiceLineOnBeforeCalcQty(var TempPurchLine: Record "Purchase Line" temporary; var PurchOrderLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCombineSalesOrderShipmentOnBeforeInsertSalesShptHeader(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var SalesOrderHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepmtLinesOnAfterShouldCalcAmounts(PurchHeader: Record "Purchase Header"; var ShouldCalcAmounts: Boolean; var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnBeforeDivideAmount(PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCombineSalesOrderShipmentOnAfterUpdateSalesOrderLine(SalesShptHeader: Record "Sales Shipment Header"; SalesOrderHeader: Record "Sales Header"; var SalesOrderLine: Record "Sales Line"; SalesShipmentLine: Record "Sales Shipment Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckICDocumentDuplicatePostingOnAfterCalcShouldCheckPosted(PurchHeader: Record "Purchase Header"; var ShouldCheckPosted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckICDocumentDuplicatePostingOnAfterCalcShouldCheckUnposted(PurchHeader: Record "Purchase Header"; var ShouldCheckUnposted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCopyToTempLines(var TempPurchLine: Record "Purchase Line" temporary; var PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUpdateCreditMemoLineOnBeforeTempPurchLineSetFilters(var TempPurchaseLine: Record "Purchase Line" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemTrackingForShipment(var PurchHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostGLAccICLineOnBeforeCreateJobPurchLine(var PurchHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeIsItemChargeLineWithQuantityToInvoice(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemChargePerRcpt(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var TempItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetAppliedOutboundItemLedgEntryNo(var ItemJnlLine: Record "Item Journal Line"; var ItemApplicationEntry: Record "Item Application Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetGeneralPostingSetup(var GeneralPostingSetup: Record "General Posting Setup"; PurchLine: Record "Purchase Line");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeConfirmJobLineType(PurchLine: Record "Purchase Line"; var HideDialog: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeConfirmJobPlanningLineNo(PurchLine: Record "Purchase Line"; var HideDialog: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemTrackingOnAfterCalcShouldProcessShipment(var PurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line"; var ShouldProcessShipment: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckItemReservDisruptionOnAfterInsertTempSKU(var Item: Record Item; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemChargePerRetRcpt(var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemChargePerTransfer(var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemChargePerRetShpt(var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemChargePerSalesShpt(var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertInvoiceHeaderOnBeforeCopyLinks(var PurchHeader: Record "Purchase Header"; var PurchInvHeader: Record "Purch. Inv. Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnBeforeUpdateIncomingDocument(var PurchHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineJobConsumptionOnAfterItemLedgEntrySetFilters(var ItemLedgEntry: Record "Item Ledger Entry"; var PurchLine: Record "Purchase Line"; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnTestPurchLineOnTypeCaseOnDocumentTypeCaseElse(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterDecrementPrepmtAmtInvLCY(PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; var PrepmtAmountInvLCY: Decimal; var PrepmtVATAmountInvLCY: Decimal)    begin    end;#if not CLEAN27    [IntegrationEvent(false, false)]    [Obsolete('This event is no longer used.', '27.0')]    local procedure OnSetPostingPreviewDocumentNo(var PreviewDocumentNo: Code[20])    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 OnInsertPostedHeadersOnAfterInvoice(var PurchaseHeader: Record "Purchase Header"; var GenJournalLine: Record "Gen. Journal Line"; var GenJnlLineDocType: Enum "Gen. Journal Document Type"; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSumPurchLines2(var PurchaseHeader: Record "Purchase Header"; var OldPurchaseLine: Record "Purchase Line"; var NewPurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateBlanketOrderLineOnTypeCaseElse(var PurchaseLine: Record "Purchase Line"; var Sign: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSumPurchLines2OnAfterIsRoundingLineInserted(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var OldPurchaseLine: Record "Purchase Line"; RoundingLineInserted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckICPartnerBlocked(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostInvoiceOnAfterPostLines(var PurchaseHeader: Record "Purchase Header"; SrcCode: Code[10]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var TotalPurchLine: Record "Purchase Line"; var TotalPurchLineLCY: Record "Purchase Line"; var TempPurchLineGlobal: Record "Purchase Line" temporary; TotalAmount: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValidatePostingAndDocumentDateOnBeforePurchaseHeaderModify(var PurchaseHeader: Record "Purchase Header"; var ModifyHeader: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdatePurchLineDimSetIDFromAppliedEntry(var PurchaseLineToPost: Record "Purchase Line"; var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterDeleteItemChargeAssgnt(var PurchaseHeader: Record "Purchase Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemChargePerRetRcpt(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var TempItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemChargePerITTransfer(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; TransRcptLine: Record "Transfer Receipt Line"; var TempItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemChargePerRetShpt(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; TempItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreatePrepaymentLinesOnBeforeShouldTestGetReceiptPPmtAmtToDeduct(PurchaseHeader: Record "Purchase Header"; CompleteFunctionality: Boolean; var ShouldTestGetReceiptPPmtAmtToDeduct: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnBeforeAmountIncludingVATAmountRound(var PurchaseLine: Record "Purchase Line"; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; Currency: Record Currency; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnBeforeCalcAmountsForFullVAT(var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckMandatoryFields(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPostingDate(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertCrMemoHeader(var PurchaseHeader: Record "Purchase Header"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr.")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertInvoiceHeader(var PurchaseHeader: Record "Purchase Header"; var PurchInvHeader: Record "Purch. Inv. Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckAndUpdateOnBeforeOnBeforeDoCommit(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnReleasePurchDocumentOnBeforeDoCommit(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssociatedSalesOrderBeforeInitOutstanding(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var SalesOrderLine: Record "Sales Line"; SalesOrderHeader: Record "Sales Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunOnBeforePostInvoice(PurchaseHeader: Record "Purchase Header"; var EverythingInvoiced: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckPurchDocumentOnBeforeCheckPurchDim(var PurchaseHeader: Record "Purchase Header"; var TempPurchLineGlobal: Record "Purchase Line" temporary; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcInvDiscountOnBeforeDoCommit(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValidatePostingAndDocumentDateOnBeforeSetReplaceDocumentDate(var PurchaseHeader: Record "Purchase Header"; var PostingDate: Date; var ReplaceDocumentDate: Boolean; var ModifyHeader: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnBeforeTempVATAmountLineGet(PurchaseLine: Record "Purchase Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckFAPostingPossibility(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPostRestrictions(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnBeforeTestGeneralPostingGroups(PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateAssosOrderPostingNosOnBeforeTestFieldBilltoCustomerNo(var SalesOrderHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDivideAmountOnAfterCalcVATBaseAmount(var PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateAfterPosting(var PurchaseHeader: Record "Purchase Header"; SuppressCommit: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckAndUpdate(var PurchaseHeader: Record "Purchase Header"; var ModifyHeader: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargeOnAfterCalcTotalChargeAmt(var PurchaseLineToPost: Record "Purchase Line"; QtyToAssign: Decimal; var PurchaseLine: Record "Purchase Line"; xPurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPurchLineOnAfterInsertReturnShipmentLine(var PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; ReturnShptHeader: Record "Return Shipment Header"; TempPurchaseLineGlobal: Record "Purchase Line"; RoundingLineInserted: Boolean; xPurchaseLine: Record "Purchase Line"; var PurchCrMemoHdr: Record "Purch. Cr. Memo Hdr.");    begin    end;    [IntegrationEvent(false, false)]    procedure OnBeforeMakeInventoryAdjustment(var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckItemReservDisruption(var PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemJnlLineOnAfterSetCheckApplToItemEntry(PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateBlanketOrderLineOnBeforeCheckBlanketOrderPurchLine(var BlanketOrderPurchaseLine: Record "Purchase Line"; PurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeModifyInvoicedQtyOnPurchRcptLine(var PurchRcptLine: Record "Purch. Rcpt. Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValidatePostingAndDocumentDateOnBeforeTestPostingDate(var PurchaseHeader: Record "Purchase Header"; ReplacePostingDate: Boolean; var SkipTestPostingDate: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckItemCharge(var ItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeProcedurePostAssocItemJnlLine(var SalesOrderLine: Record "Sales Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempHandlingSpecification: Record "Tracking Specification" temporary; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal; var ItemShptEntryNo: Integer; 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 OnBeforeCalcItemJnlLineToBeInvoicedAmounts(var ItemJournalLine: Record "Item Journal Line"; var PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; var RemAmt: Decimal; var RemDiscAmt: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemJnlLineWhseLine(var TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary; PurchaseLine: Record "Purchase Line"; PostBefore: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItemJnlLineWhseLine(var TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary; PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemChargePerTransferOnBeforeProcessItemApplicationEntry(PurchaseLine: Record "Purchase Line"; ItemApplicationEntry: Record "Item Application Entry"; TransferReceiptLine: Record "Transfer Receipt Line"; TotalAmountToPostFCY: Decimal; var AmountToPostFCY: Decimal; GeneralLedgerSetup: Record "General Ledger Setup"; PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemCharge(PurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line"; ItemEntryNo: Integer; QuantityBase: Decimal; AmountToAssign: Decimal; QtyToAssign: Decimal; IndirectCostPct: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertedPrepmtVATBaseToDeductOnAfterSetTempPrepmtDeductLCYPurchaseLine(var TempPrepmtDeductLCYPurchaseLine: Record "Purchase Line" temporary; var PrepmtVATBaseToDeduct: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeAdjustPrepmtAmountLCY(PurchaseHeader: Record "Purchase Header"; var PrepmtPurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeAdjustFinalInvWith100PctPrepmt(var CombinedPurchaseLine: Record "Purchase Line"; var TempPrepmtDeductLCYPurchaseLine: Record "Purchase Line" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateInvoicedQtyOnReturnShipmentLine(var ReturnShipmentLine: Record "Return Shipment Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckPurchRcptLine(PurchRcptLine: Record "Purch. Rcpt. Line"; PurchaseLine: Record "Purchase Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateItemChargeAssgntOnBeforeItemChargeAssignmentPurchModify(var ItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateReceiptInvoicingQuantities(PurchLine: Record "Purchase Line"; var SkipQuantityUpdate: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetCommitBehavior(var IgnoreCommit: Boolean)    begin    end;}