Codeunit 22 Item Jnl.-Post Line

Base Application, Microsoft.Inventory.Posting

src/Layers/W1/BaseApp/Inventory/Posting/ItemJnlPostLine.Codeunit.al8,995 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.Inventory.Posting;using Microsoft.Assembly.Document;using Microsoft.Finance.Currency;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Finance.VAT.Setup;using Microsoft.Foundation.AuditCodes;using Microsoft.Foundation.Enums;using Microsoft.Foundation.NoSeries;using Microsoft.Foundation.UOM;using Microsoft.Inventory.Costing;using Microsoft.Inventory.Counting.Journal;using Microsoft.Inventory.Item;using Microsoft.Inventory.Journal;using Microsoft.Inventory.Ledger;using Microsoft.Inventory.Location;using Microsoft.Inventory.Setup;using Microsoft.Inventory.Tracking;using Microsoft.Projects.Project.Planning;using Microsoft.Sales.Document;using Microsoft.Warehouse.Journal;codeunit 22 "Item Jnl.-Post Line"{    Permissions = TableData Item = rimd,                  TableData "Item Ledger Entry" = rimd,                  TableData "Item Register" = rimd,                  TableData "Phys. Inventory Ledger Entry" = rimd,                  TableData "Item Application Entry" = rimd,#if not CLEAN28                  TableData Microsoft.Manufacturing.Document."Prod. Order Capacity Need" = rimd,#endif                  TableData "Stockkeeping Unit" = rimd,                  TableData "Value Entry" = rimd,                  TableData "Avg. Cost Adjmt. Entry Point" = rim,                  TableData "Post Value Entry to G/L" = ri,                  TableData Microsoft.Manufacturing.Capacity."Capacity Ledger Entry" = rimd,                  TableData "Inventory Adjmt. Entry (Order)" = rim,                  TableData "Job Planning Line" = r;    TableNo = "Item Journal Line";    trigger OnRun()    begin        GetGLSetup();        RunWithCheck(Rec);    end;    var        GLSetup: Record "General Ledger Setup";        Currency: Record Currency;        InvtSetup: Record "Inventory Setup";        Location: Record Location;        NewLocation: Record Location;        Item: Record Item;        ItemVariant: Record "Item Variant";        GlobalItemLedgEntry: Record "Item Ledger Entry";        OldItemLedgEntry: Record "Item Ledger Entry";        ItemReg: Record "Item Register";        ItemJnlLine: Record "Item Journal Line";        ItemJnlLineOrigin: Record "Item Journal Line";        SourceCodeSetup: Record "Source Code Setup";        GenPostingSetup: Record "General Posting Setup";        ItemApplnEntry: Record "Item Application Entry";        GlobalValueEntry: Record "Value Entry";        DirCostValueEntry: Record "Value Entry";        SKU: Record "Stockkeeping Unit";        CurrExchRate: Record "Currency Exchange Rate";        GlobalItemTrackingCode: Record "Item Tracking Code";        GlobalItemTrackingSetup: Record "Item Tracking Setup";        TempSplitItemJnlLine: Record "Item Journal Line" temporary;        TempTrackingSpecification: Record "Tracking Specification" temporary;        TempValueEntryRelation: Record "Value Entry Relation" temporary;        TempItemEntryRelation: Record "Item Entry Relation" temporary;        TempJobPlanningLine: Record "Job Planning Line" temporary;        TempTouchedItemLedgerEntries: Record "Item Ledger Entry" temporary;        TempItemApplnEntryHistory: Record "Item Application Entry History" temporary;        PrevAppliedItemLedgEntry: Record "Item Ledger Entry";        WhseJnlRegisterLine: Codeunit "Whse. Jnl.-Register Line";        ItemJnlCheckLine: Codeunit "Item Jnl.-Check Line";        ReservEngineMgt: Codeunit "Reservation Engine Mgt.";        ItemJnlLineReserve: Codeunit "Item Jnl. Line-Reserve";        JobPlanningLineReserve: Codeunit "Job Planning Line-Reserve";        ItemTrackingMgt: Codeunit "Item Tracking Management";        InventoryPostingToGL: Codeunit "Inventory Posting To G/L";        AvgCostEntryPointHandler: Codeunit "Avg. Cost Entry Point Handler";        ACYMgt: Codeunit "Additional-Currency Management";        ItemLedgEntryNo: Integer;        PhysInvtEntryNo: Integer;        CapLedgEntryNo: Integer;        ValueEntryNo: Integer;        ItemApplnEntryNo: Integer;        TotalAppliedQty: Decimal;        OverheadAmount: Decimal;        VarianceAmount: Decimal;        OverheadAmountACY: Decimal;        VarianceAmountACY: Decimal;        QtyPerUnitOfMeasure: Decimal;        RoundingResidualAmount: Decimal;        RoundingResidualAmountACY: Decimal;        RoundingResidualAmountInvdACY: Decimal;        InvtSetupRead: Boolean;        GLSetupRead: Boolean;        SKUExists: Boolean;        AverageTransfer: Boolean;        PostponeReservationHandling: Boolean;        ProdOrderCompModified: Boolean;        VarianceRequired: Boolean;        LastOperation: Boolean;        DisableItemTracking: Boolean;        CalledFromInvtPutawayPick: Boolean;        CalledFromAdjustment: Boolean;        PostToGL: Boolean;        IsServUndoConsumption: Boolean;        SkipRetrieveItemTracking: Boolean;        SkipApplicationCheck: Boolean;        CalledFromApplicationWorksheet: Boolean;        SkipSerialNoQtyValidation: Boolean;#pragma warning disable AA0074#pragma warning disable AA0470        Text003: Label 'Reserved item %1 is not on inventory.';        Text004: Label 'is too low';        TrackingSpecificationMissingErr: Label 'Tracking Specification is missing.';        Text012: Label 'Item %1 must be reserved.';        Text014: Label 'Serial No. %1 is already on inventory.';        SerialNoRequiredErr: Label 'You must assign a serial number for item %1.', Comment = '%1 - Item No.';        LotNoRequiredErr: Label 'You must assign a lot number for item %1.', Comment = '%1 - Item No.';        LineNoTxt: Label ' Line No. = ''%1''.', Comment = '%1 - Line No.';        Text017: Label ' is before the posting date.';        Text018: Label 'Item Tracking Serial No. %1 Lot No. %2 for Item No. %3 Variant %4 cannot be fully applied.';        Text022: Label 'You cannot apply %1 to %2 on the same item %3 on Production Order %4.';        Text100: Label 'Fatal error when retrieving Tracking Specification.';        Text99000000: Label 'must not be filled out when reservations exist';        CannotUnapplyCorrEntryErr: Label 'Entries applied to a Correction entry cannot be unapplied.';        CannotUnapplyItemLedgEntryErr: Label 'You cannot proceed with the posting as it will result in negative inventory for item %1. \Item ledger entry %2 cannot be left unapplied.', Comment = '%1 - Item no., %2 - Item ledger entry no.';        Text023: Label 'Entries applied to an Outbound Transfer cannot be unapplied.';        Text024: Label 'Entries applied to a Drop Shipment Order cannot be unapplied.';        Text027: Label 'A fixed application was not unapplied and this prevented the reapplication. Use the Application Worksheet to remove the applications.';        Text01: Label 'Checking for open entries.';        Text029: Label '%1 %2 for %3 %4 is reserved for %5.';        Text030: Label 'The quantity that you are trying to invoice is larger than the quantity in the item ledger with the entry number %1.';        Text033: Label 'Quantity must be -1, 0 or 1 when Serial No. is stated.';        PostToGlLbl: Label 'Posting to G/L    #1#####', Comment = '%1 is an integer value';        CanOnlyBeUsedForDropShipmentErr: Label 'This can be only used for Drop Shipment applications.';        DropShipmentCostApplicationsCannotBeUnappliedErr: Label 'Drop Shipment cost applications cannot be unapplied.';        ValuationDateBeforeEarliestAllowedErr: Label 'The Valuation Date %1 is before the Earliest Allowed Valuation Date %2 in Inventory Setup.', Comment = '%1 = Valuation Date, %2 = Earliest Allowed Valuation Date';        ApplyToEntryValuationDateErr: Label 'Applying to entry %1 would result in a Valuation Date %2 before the Earliest Allowed Valuation Date %3 in Inventory Setup.', Comment = '%1 = Entry No., %2 = Valuation Date, %3 = Earliest Allowed Valuation Date';#pragma warning restore AA0074#pragma warning restore AA0470    /// <summary>    /// Posts the provided item journal line. The line is copied to a global variable. A check is performed to ensure the Item and Variant are not blocked.    /// </summary>    /// <param name="ItemJnlLine2">Item journal line to post.</param>    /// <returns>True if item journal line was posted, otherwise false.</returns>    procedure RunWithCheck(var ItemJnlLine2: Record "Item Journal Line"): Boolean    var        SequenceNoMgt: Codeunit "Sequence No. Mgt.";        TrackingSpecExists: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRunWithCheck(ItemJnlLine2, CalledFromAdjustment, CalledFromInvtPutawayPick, CalledFromApplicationWorksheet, PostponeReservationHandling, IsHandled);        if IsHandled then            exit;        if ItemReg."No." = 0 then  // first time in this transaction?            SequenceNoMgt.ClearSequenceNoCheck();        PrepareItem(ItemJnlLine2);        TrackingSpecExists := ItemTrackingMgt.RetrieveItemTracking(ItemJnlLine2, TempTrackingSpecification);        OnRunWithCheckOnAfterRetrieveItemTracking(ItemJnlLine2, TempTrackingSpecification, TrackingSpecExists, PostponeReservationHandling);        exit(PostSplitJnlLine(ItemJnlLine2, TrackingSpecExists));    end;    /// <summary>    /// Posts the item journal line. Item journal lines are split before posting based on item tracking specification.    /// </summary>    /// <param name="ItemJnlLine2">Item journal line to post.</param>    /// <param name="ReservationEntry">Return value: Get the set of reservation entries used in posting.</param>    /// <returns>True if item journal line was posted, otherwise false.</returns>    procedure RunPostWithReservation(var ItemJnlLine2: Record "Item Journal Line"; var ReservationEntry: Record "Reservation Entry") ItemJournalLinePosted: Boolean    var        TrackingSpecExists: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRunPostWithReservation(ItemJnlLine2, ReservationEntry, ItemJournalLinePosted, IsHandled);        if IsHandled then            exit(ItemJournalLinePosted);        PrepareItem(ItemJnlLine2);        ReservationEntry.Reset();        TrackingSpecExists :=          ItemTrackingMgt.RetrieveItemTrackingFromReservEntry(ItemJnlLine2, ReservationEntry, TempTrackingSpecification);        exit(PostSplitJnlLine(ItemJnlLine2, TrackingSpecExists));    end;    local procedure "Code"()    var        xItemLedgEntryNo: Integer;        xItemApplnEntryNo: Integer;        xValueEntryNo: Integer;        IsHandled: Boolean;    begin        xItemLedgEntryNo := ItemLedgEntryNo;        xItemApplnEntryNo := ItemApplnEntryNo;        xValueEntryNo := ValueEntryNo;        OnBeforePostItemJnlLine(ItemJnlLine, CalledFromAdjustment, CalledFromInvtPutawayPick, ItemReg, ItemLedgEntryNo, ValueEntryNo, ItemApplnEntryNo, PhysInvtEntryNo, CapLedgEntryNo);        ValidateSequenceNo(ItemLedgEntryNo, xItemLedgEntryNo, Database::"Item Ledger Entry");        ValidateSequenceNo(ItemApplnEntryNo, xItemApplnEntryNo, Database::"Item Application Entry");        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");        if ItemJnlLine.EmptyLine() and not ItemJnlLine.Correction and not ItemJnlLine.Adjustment then            if not ItemJnlLine.IsValueEntryForDeletedItem() then                exit;        ItemJnlCheckLine.SetCalledFromInvtPutawayPick(CalledFromInvtPutawayPick);        ItemJnlCheckLine.SetCalledFromAdjustment(CalledFromAdjustment);        OnCodeOnBeforeRunCheck(ItemJnlCheckLine, ItemJnlLine);        ItemJnlCheckLine.RunCheck(ItemJnlLine);        OnCodeOnAfterRunCheck(ItemJnlLine);        if ItemJnlLine."Document Date" = 0D then            ItemJnlLine."Document Date" := ItemJnlLine."Posting Date";        if ItemJnlLine."VAT Reporting Date" = 0D then            ItemJnlLine."VAT Reporting Date" := GLSetup.GetVATDate(ItemJnlLine."Posting Date", ItemJnlLine."Document Date");        if (ItemLedgEntryNo = 0) and InvtSetup.UseLegacyPosting() then begin            GlobalItemLedgEntry.LockTable();            ItemLedgEntryNo := GlobalItemLedgEntry.GetLastEntryNo();            GlobalItemLedgEntry."Entry No." := ItemLedgEntryNo;        end;        InitValueEntryNo();        GetInvtSetup();        if not CalledFromAdjustment then            PostToGL := InvtSetup."Automatic Cost Posting";        OnCheckPostingCostToGL(PostToGL);        IsHandled := false;        OnCodeOnBeforeCheckItemTracking(ItemJnlLine, DisableItemTracking, IsHandled, TempTrackingSpecification, GlobalItemTrackingSetup);        if not IsHandled then            if GlobalItemTrackingSetup.TrackingRequired() and (ItemJnlLine."Quantity (Base)" <> 0) and               (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and               not DisableItemTracking and not ItemJnlLine.Adjustment and               not ItemJnlLine.Subcontracting and not ItemJnlLine.IsAssemblyResourceConsumpLine()            then                CheckItemTracking(ItemJnlLine);        if ItemJnlLine.Correction and not ItemJnlLine.Subcontracting then            UndoQuantityPosting();        if (ItemJnlLine."Entry Type" in            [ItemJnlLine."Entry Type"::Consumption, ItemJnlLine."Entry Type"::Output, ItemJnlLine."Entry Type"::"Assembly Consumption", ItemJnlLine."Entry Type"::"Assembly Output"]) and           not (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::Revaluation) and           not ItemJnlLine.OnlyStopTime()        then begin            case ItemJnlLine."Entry Type" of                ItemJnlLine."Entry Type"::"Assembly Consumption", ItemJnlLine."Entry Type"::"Assembly Output":                    ItemJnlLine.TestField("Order Type", ItemJnlLine."Order Type"::Assembly);                ItemJnlLine."Entry Type"::Consumption, ItemJnlLine."Entry Type"::Output:                    ItemJnlLine.TestField("Order Type", ItemJnlLine."Order Type"::Production);            end;            IsHandled := false;            OnCodeOnBeforeTestOrder(ItemJnlLine, IsHandled);            if not IsHandled then begin                ItemJnlLine.TestField("Order No.");                if ItemJnlLine.IsAssemblyOutputLine() then                    ItemJnlLine.TestField("Order Line No.", 0)                else                    ItemJnlLine.TestField("Order Line No.");            end;        end;        GetGeneralPostingSetup(ItemJnlLine);        if ItemJnlLine."Qty. per Unit of Measure" = 0 then            ItemJnlLine."Qty. per Unit of Measure" := 1;        if ItemJnlLine."Qty. per Cap. Unit of Measure" = 0 then            ItemJnlLine."Qty. per Cap. Unit of Measure" := 1;        OnCodeOnBeforeSetQuantity(ItemJnlLine);        ItemJnlLine.Quantity := ItemJnlLine."Quantity (Base)";        ItemJnlLine."Invoiced Quantity" := ItemJnlLine."Invoiced Qty. (Base)";        if not ItemJnlLine.Subcontracting and           ((ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Output) or            ItemJnlLine.IsAssemblyResourceConsumpLine())        then            QtyPerUnitOfMeasure := ItemJnlLine."Qty. per Cap. Unit of Measure"        else            QtyPerUnitOfMeasure := ItemJnlLine."Qty. per Unit of Measure";        OnCodeOnAfterCalcQtyPerUnitOfMeasure(ItemJnlLine, ItemJnlLine.Subcontracting, QtyPerUnitOfMeasure);        RoundingResidualAmount := 0;        RoundingResidualAmountACY := 0;        RoundingResidualAmountInvdACY := 0;        RoundingResidualAmount := ItemJnlLine.Quantity *          (ItemJnlLine."Unit Cost" / QtyPerUnitOfMeasure - Round(ItemJnlLine."Unit Cost" / QtyPerUnitOfMeasure, GLSetup."Unit-Amount Rounding Precision"));        RoundingResidualAmountACY := ItemJnlLine.Quantity *          (ItemJnlLine."Unit Cost (ACY)" / QtyPerUnitOfMeasure - Round(ItemJnlLine."Unit Cost (ACY)" / QtyPerUnitOfMeasure, Currency."Unit-Amount Rounding Precision"));        RoundingResidualAmountInvdACY := ItemJnlLine."Invoiced Quantity" *          (ItemJnlLine."Unit Cost (ACY)" / QtyPerUnitOfMeasure - Round(ItemJnlLine."Unit Cost (ACY)" / QtyPerUnitOfMeasure, Currency."Unit-Amount Rounding Precision"));        ItemJnlLine."Unit Amount" := Round(            ItemJnlLine."Unit Amount" / QtyPerUnitOfMeasure, GLSetup."Unit-Amount Rounding Precision");        ItemJnlLine."Unit Cost" := Round(            ItemJnlLine."Unit Cost" / QtyPerUnitOfMeasure, GLSetup."Unit-Amount Rounding Precision");        ItemJnlLine."Unit Cost (ACY)" := Round(            ItemJnlLine."Unit Cost (ACY)" / QtyPerUnitOfMeasure, Currency."Unit-Amount Rounding Precision");        OverheadAmount := 0;        VarianceAmount := 0;        OverheadAmountACY := 0;        VarianceAmountACY := 0;        VarianceRequired := false;        LastOperation := false;        OnBeforePostLineByEntryType(ItemJnlLine, CalledFromAdjustment, CalledFromInvtPutawayPick);        case true of            ItemJnlLine.IsAssemblyResourceConsumpLine():                PostAssemblyResourceConsump();            ItemJnlLine.Adjustment,            ItemJnlLine."Value Entry Type" in [ItemJnlLine."Value Entry Type"::Rounding, ItemJnlLine."Value Entry Type"::Revaluation],            ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::"Assembly Consumption",            ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::"Assembly Output":                PostItem();            ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Consumption:                PostConsumption(ItemJnlLine);            ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Output:                PostOutput(ItemJnlLine);            not ItemJnlLine.Correction:                PostItem();        end;        // Entry no. is returned to shipment/receipt        if ItemJnlLine.Subcontracting then            ItemJnlLine."Item Shpt. Entry No." := CapLedgEntryNo        else            ItemJnlLine."Item Shpt. Entry No." := GlobalItemLedgEntry."Entry No.";        xItemLedgEntryNo := ItemLedgEntryNo;        xItemApplnEntryNo := ItemApplnEntryNo;        xValueEntryNo := ValueEntryNo;        OnAfterPostItemJnlLine(ItemJnlLine, GlobalItemLedgEntry, ValueEntryNo, InventoryPostingToGL, CalledFromAdjustment, CalledFromInvtPutawayPick, ItemReg, ItemLedgEntryNo, ItemApplnEntryNo, WhseJnlRegisterLine, PhysInvtEntryNo, CapLedgEntryNo);        ValidateSequenceNo(ItemLedgEntryNo, xItemLedgEntryNo, Database::"Item Ledger Entry");        ValidateSequenceNo(ItemApplnEntryNo, xItemApplnEntryNo, Database::"Item Application Entry");        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");    end;    /// <summary>    /// Splits the item journal line into multiple lines based on item tracking specification and posts them.    /// <remarks>    /// After posting, corrects the valuation date of output entries in the item ledger     /// based on the maximum consumption valuation date.    /// </remarks>    /// </summary>    /// <param name="ItemJnlLineToPost">Item journal line to post.</param>    /// <param name="TrackingSpecExists">True, if item tracking exists, otherwise false.</param>    /// <returns>True if item journal line was posted, otherwise false.</returns>    procedure PostSplitJnlLine(var ItemJnlLineToPost: Record "Item Journal Line"; TrackingSpecExists: Boolean): Boolean    var        IgnoreCommit: Boolean;    begin        IgnoreCommit := true;        OnSetCommitBehavior(IgnoreCommit);        if IgnoreCommit then            exit(PostSplitJnlLineCommitBehaviorIgnore(ItemJnlLineToPost, TrackingSpecExists));        exit(RunPostSplitJnlLine(ItemJnlLineToPost, TrackingSpecExists));    end;    [CommitBehavior(CommitBehavior::Ignore)]    local procedure PostSplitJnlLineCommitBehaviorIgnore(var ItemJnlLineToPost: Record "Item Journal Line"; TrackingSpecExists: Boolean): Boolean    begin        exit(RunPostSplitJnlLine(ItemJnlLineToPost, TrackingSpecExists));    end;    local procedure RunPostSplitJnlLine(var ItemJnlLineToPost: Record "Item Journal Line"; TrackingSpecExists: Boolean): Boolean    var        PostItemJnlLine: Boolean;    begin        PostItemJnlLine := SetupSplitJnlLine(ItemJnlLineToPost, TrackingSpecExists);        if not PostItemJnlLine then            PostItemJnlLine := IsNotInternalWhseMovement(ItemJnlLineToPost);        OnPostSplitJnlLineOnBeforeSplitJnlLine(ItemJnlLine, ItemJnlLineToPost, PostItemJnlLine, DisableItemTracking);        while SplitItemJnlLine(ItemJnlLine, PostItemJnlLine) do            if PostItemJnlLine then                Code();        OnPostSplitJnlLineOnAfterCode(ItemJnlLine, ItemJnlLineToPost, PostItemJnlLine, TempTrackingSpecification, DisableItemTracking);        Clear(PrevAppliedItemLedgEntry);        ItemJnlLineToPost := ItemJnlLine;        CorrectOutputValuationDate(GlobalItemLedgEntry);        RedoApplications();        OnAfterPostSplitJnlLine(ItemJnlLineToPost, TempTrackingSpecification);        exit(PostItemJnlLine);    end;    local procedure PostConsumption(var ItemJnlLine2: Record "Item Journal Line")    begin        OnPostConsumption(ItemJnlLine2, GlobalItemTrackingSetup, TempSplitItemJnlLine, ProdOrderCompModified, ItemLedgEntryNo);    end;    local procedure PostOutput(var ItemJnlLine2: Record "Item Journal Line")    begin        OnPostOutput(ItemJnlLine2, GlobalItemTrackingSetup, GlobalItemTrackingCode, GlobalItemLedgEntry, LastOperation);    end;    /// <summary>    /// Updates item journal line with information from the item or SKU and posts it creating item ledger,     /// value and item application entries.    /// </summary>    procedure PostItem()    begin        PostItem(ItemJnlLine);    end;    procedure PostItem(var ItemJnlLine: Record "Item Journal Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostItem(ItemJnlLine, IsHandled, CalledFromAdjustment, ItemReg);        if IsHandled then            exit;        SKUExists := SKU.Get(ItemJnlLine."Location Code", ItemJnlLine."Item No.", ItemJnlLine."Variant Code");        IsHandled := false;        OnPostItemOnAfterGetSKU(ItemJnlLine, SKUExists, IsHandled);        if not IsHandled then            if ItemJnlLine."Item Shpt. Entry No." <> 0 then                if not CheckIfReservationEntryForJobExist() then begin                    ItemJnlLine."Location Code" := '';                    ItemJnlLine."Variant Code" := '';                end;        if GetItem(ItemJnlLine."Item No.", false) then            CheckIfItemIsBlocked();        if GetItemVariant(ItemJnlLine."Item No.", ItemJnlLine."Variant Code", false) then            CheckIfItemVariantIsBlocked();        OnPostItemOnBeforeCheckInventoryPostingGroup(ItemJnlLine, CalledFromAdjustment, Item, GlobalItemTrackingCode);        if (ItemJnlLine."Inventory Posting Group" = '') and (Item.Type = Item.Type::Inventory) then begin            Item.TestField("Inventory Posting Group");            ItemJnlLine."Inventory Posting Group" := Item."Inventory Posting Group";        end;        OnPostItemOnBeforeSetAverageTransfer(ItemJnlLine, CalledFromAdjustment);        if (ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Transfer) and           (Item."Costing Method" = Item."Costing Method"::Average) and           (ItemJnlLine."Applies-to Entry" = 0)        then begin            AverageTransfer := true;            TotalAppliedQty := 0;        end else            AverageTransfer := false;        IsHandled := false;        OnPostItemOnBeforeTransferReservFromJobPlanningLine(ItemJnlLine, IsHandled, AverageTransfer);        if not IsHandled then            if ItemJnlLine."Job Contract Entry No." <> 0 then                TransReserveFromJobPlanningLine(ItemJnlLine."Job Contract Entry No.", ItemJnlLine);        if Item."Costing Method" = Item."Costing Method"::Standard then begin            OnPostItemOnAfterCheckCostingMethodStandard(Item, ItemJnlLine);            ItemJnlLine."Overhead Rate" := Item."Overhead Rate";            ItemJnlLine."Indirect Cost %" := Item."Indirect Cost %";            OnPostItemOnAfterSetItemJnlCostingMethodStandard(Item, ItemJnlLine);        end;        if (ItemJnlLine."Value Entry Type" <> ItemJnlLine."Value Entry Type"::"Direct Cost") or           (ItemJnlLine."Item Charge No." <> '')        then begin            ItemJnlLine."Overhead Rate" := 0;            ItemJnlLine."Indirect Cost %" := 0;        end;        if (ItemJnlLine.Quantity <> 0) and           (ItemJnlLine."Item Charge No." = '') and           not (ItemJnlLine."Value Entry Type" in [ItemJnlLine."Value Entry Type"::Revaluation, ItemJnlLine."Value Entry Type"::Rounding]) and           not ItemJnlLine.Adjustment        then            ItemQtyPosting()        else            if (ItemJnlLine."Invoiced Quantity" <> 0) or ItemJnlLine.Adjustment or               IsInterimRevaluation()            then begin                if ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost" then begin                    if Item.Type <> Item.Type::"Non-Inventory" then begin                        IsHandled := false;                        OnPostItemOnBeforeGetGlobalLedgerEntry(ItemJnlLine, IsHandled);                        if not IsHandled then                            GlobalItemLedgEntry.Get(ItemJnlLine."Item Shpt. Entry No.")                    end else                        if not GlobalItemLedgEntry.Get(ItemJnlLine."Item Shpt. Entry No.") then                            exit;                end else                    GlobalItemLedgEntry.Get(ItemJnlLine."Applies-to Entry");                CorrectOutputValuationDate(GlobalItemLedgEntry);                InitValueEntry(GlobalValueEntry, GlobalItemLedgEntry);            end;        CheckRunItemValuePosting();        OnPostItemOnBeforeUpdateUnitCost(ItemJnlLine, GlobalItemLedgEntry);        UpdateUnitCost(GlobalValueEntry);        OnAfterPostItem(ItemJnlLine, CalledFromAdjustment);    end;    internal procedure CalcDirAndIndirCostAmts(var DirCostAmt: Decimal; var IndirCostAmt: Decimal; CapQty: Decimal; var ItemJournalLine: Record "Item Journal Line")    var        CostAmt: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcDirAndIndirCostAmts(ItemJournalLine, DirCostAmt, IndirCostAmt, CapQty, IsHandled);        if IsHandled then            exit;        CostAmt := CapQty * ItemJournalLine."Unit Cost";        if ItemJournalLine.Subcontracting then            CostAmt += RoundingResidualAmount;        CostAmt := Round(CostAmt);        DirCostAmt := Round((CostAmt - CapQty * ItemJournalLine."Overhead Rate") / (1 + ItemJournalLine."Indirect Cost %" / 100));        IndirCostAmt := CostAmt - DirCostAmt;    end;    internal procedure InsertCapLedgEntry(var ItemJnlLine: Record "Item Journal Line"; var CapLedgEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; Qty: Decimal; InvdQty: Decimal)    var        IsHandled: Boolean;    begin        OnBeforeProcedureInsertCapLedgEntry(ItemJnlLine, CapLedgEntry, IsHandled);        if IsHandled then            exit;        if InvtSetup.UseLegacyPosting() then begin            if CapLedgEntryNo = 0 then begin                CapLedgEntry.LockTable();                CapLedgEntryNo := CapLedgEntry.GetLastEntryNo();            end;            CapLedgEntryNo += 1;        end else            CapLedgEntryNo := CapLedgEntry.GetNextEntryNo();        CapLedgEntry.Init();        CapLedgEntry."Entry No." := CapLedgEntryNo;        CapLedgEntry.Type := ItemJnlLine.Type;        CapLedgEntry."No." := ItemJnlLine."No.";        CapLedgEntry.Description := ItemJnlLine.Description;        CapLedgEntry.Subcontracting := ItemJnlLine.Subcontracting;        CapLedgEntry.Quantity := Qty;        CapLedgEntry."Invoiced Quantity" := InvdQty;        CapLedgEntry."Completely Invoiced" := CapLedgEntry."Invoiced Quantity" = CapLedgEntry.Quantity;        if ItemJnlLine."Unit Cost Calculation" = ItemJnlLine."Unit Cost Calculation"::Time then begin            CapLedgEntry."Cap. Unit of Measure Code" := ItemJnlLine."Cap. Unit of Measure Code";            CapLedgEntry."Qty. per Cap. Unit of Measure" := ItemJnlLine."Qty. per Cap. Unit of Measure";        end;        CapLedgEntry."Item No." := ItemJnlLine."Item No.";        CapLedgEntry."Variant Code" := ItemJnlLine."Variant Code";        CapLedgEntry."Unit of Measure Code" := ItemJnlLine."Unit of Measure Code";        CapLedgEntry."Qty. per Unit of Measure" := ItemJnlLine."Qty. per Unit of Measure";        CapLedgEntry."Order Type" := ItemJnlLine."Order Type";        CapLedgEntry."Order No." := ItemJnlLine."Order No.";        CapLedgEntry."Order Line No." := ItemJnlLine."Order Line No.";        CapLedgEntry."Posting Date" := ItemJnlLine."Posting Date";        CapLedgEntry."Document Date" := ItemJnlLine."Document Date";        CapLedgEntry."Document No." := ItemJnlLine."Document No.";        CapLedgEntry."External Document No." := ItemJnlLine."External Document No.";        CapLedgEntry."Global Dimension 1 Code" := ItemJnlLine."Shortcut Dimension 1 Code";        CapLedgEntry."Global Dimension 2 Code" := ItemJnlLine."Shortcut Dimension 2 Code";        CapLedgEntry."Dimension Set ID" := ItemJnlLine."Dimension Set ID";        OnBeforeInsertCapLedgEntry(CapLedgEntry, ItemJnlLine, LastOperation);        InsertItemReg(0, 0, 0, CapLedgEntry."Entry No.");        CapLedgEntry."Item Register No." := ItemReg."No.";        CapLedgEntry.Insert(true);        OnAfterInsertCapLedgEntry(CapLedgEntry, ItemJnlLine);    end;    procedure InsertCapValueEntry(var ItemJournalLine: Record "Item Journal Line"; var CapLedgEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; ValueEntryType: Enum "Cost Entry Type"; ValuedQty: Decimal; InvdQty: Decimal; AdjdCost: Decimal)    var        ValueEntry: Record "Value Entry";        IsHandled: Boolean;    begin        OnBeforeInsertCapValueEntryProcedure(ItemJournalLine, ValueEntryType, ValuedQty, InvdQty, AdjdCost);        if (InvdQty = 0) and (AdjdCost = 0) then            exit;        ValueEntryNo := GetNextValueEntryNo(ValueEntryNo);        ValueEntry.Init();        ValueEntry."Entry No." := ValueEntryNo;        ValueEntry."Capacity Ledger Entry No." := CapLedgEntry."Entry No.";        ValueEntry."Entry Type" := ValueEntryType;        ValueEntry."Item Ledger Entry Type" := ValueEntry."Item Ledger Entry Type"::" ";        ValueEntry.Type := ItemJournalLine.Type;        ValueEntry."No." := ItemJournalLine."No.";        ValueEntry.Description := ItemJournalLine.Description;        ValueEntry."Order Type" := ItemJournalLine."Order Type";        ValueEntry."Order No." := ItemJournalLine."Order No.";        ValueEntry."Order Line No." := ItemJournalLine."Order Line No.";        ValueEntry."Source Type" := ItemJournalLine."Source Type";        ValueEntry."Source No." := GetSourceNo(ItemJournalLine);        ValueEntry."Invoiced Quantity" := InvdQty;        ValueEntry."Valued Quantity" := ValuedQty;        ValueEntry."Cost Amount (Actual)" := AdjdCost;        ValueEntry."Cost Amount (Actual) (ACY)" := ACYMgt.CalcACYAmt(AdjdCost, ItemJournalLine."Posting Date", false);        OnInsertCapValueEntryOnAfterUpdateCostAmounts(ValueEntry, ItemJournalLine);        ValueEntry."Cost per Unit" :=          CalcCostPerUnit(ValueEntry."Cost Amount (Actual)", ValueEntry."Valued Quantity", false);        ValueEntry."Cost per Unit (ACY)" :=          CalcCostPerUnit(ValueEntry."Cost Amount (Actual) (ACY)", ValueEntry."Valued Quantity", true);        ValueEntry.Inventoriable := true;        if ItemJournalLine.Type = ItemJournalLine.Type::Resource then            ItemJournalLine.TestField("Inventory Posting Group", '')        else            ItemJournalLine.TestField("Inventory Posting Group");        ValueEntry."Inventory Posting Group" := ItemJournalLine."Inventory Posting Group";        ValueEntry."Gen. Bus. Posting Group" := ItemJournalLine."Gen. Bus. Posting Group";        ValueEntry."Gen. Prod. Posting Group" := ItemJournalLine."Gen. Prod. Posting Group";        ValueEntry."Posting Date" := ItemJournalLine."Posting Date";        ValueEntry."Valuation Date" := ItemJournalLine."Posting Date";        ValueEntry."Source No." := GetSourceNo(ItemJournalLine);        ValueEntry."Document Type" := ItemJournalLine."Document Type";        if ValueEntry."Expected Cost" or (ItemJournalLine."Invoice No." = '') then            ValueEntry."Document No." := ItemJournalLine."Document No."        else begin            ValueEntry."Document No." := ItemJournalLine."Invoice No.";            if ItemJournalLine."Document Type" in               [ItemJournalLine."Document Type"::"Purchase Receipt", ItemJournalLine."Document Type"::"Purchase Return Shipment",                ItemJournalLine."Document Type"::"Sales Shipment", ItemJournalLine."Document Type"::"Sales Return Receipt",                ItemJournalLine."Document Type"::"Service Shipment"]            then                ValueEntry."Document Type" := Enum::"Item Ledger Document Type".FromInteger(ItemJournalLine."Document Type".AsInteger() + 1);        end;        ValueEntry."Document Line No." := ItemJournalLine."Document Line No.";        ValueEntry."Document Date" := ItemJournalLine."Document Date";        ValueEntry."External Document No." := ItemJournalLine."External Document No.";        ValueEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(ValueEntry."User ID"));        ValueEntry."Source Code" := ItemJournalLine."Source Code";        ValueEntry."Reason Code" := ItemJournalLine."Reason Code";        ValueEntry."Journal Batch Name" := ItemJournalLine."Journal Batch Name";        ValueEntry."Global Dimension 1 Code" := ItemJournalLine."Shortcut Dimension 1 Code";        ValueEntry."Global Dimension 2 Code" := ItemJournalLine."Shortcut Dimension 2 Code";        ValueEntry."Dimension Set ID" := ItemJournalLine."Dimension Set ID";        OnBeforeInsertCapValueEntry(ValueEntry, ItemJournalLine);        IsHandled := false;        OnInsertCapValueEntryOnBeforeInventoryPostingToGL(ValueEntry, IsHandled, PostToGL);        if not IsHandled then begin            InventoryPostingToGL.SetRunOnlyCheck(true, not InvtSetup."Automatic Cost Posting", false);            PostInvtBuffer(ValueEntry);        end;        InsertItemReg(0, 0, ValueEntry."Entry No.", 0);        ValueEntry."Item Register No." := ItemReg."No.";        ValueEntry.Insert(true);        OnAfterInsertCapValueEntry(ValueEntry, ItemJournalLine);        UpdateAdjmtProperties(ValueEntry, CapLedgEntry."Posting Date");        InsertPostValueEntryToGL(ValueEntry);        if Item."Item Tracking Code" <> '' then begin            TempValueEntryRelation.Init();            TempValueEntryRelation."Value Entry No." := ValueEntry."Entry No.";            TempValueEntryRelation.Insert();        end;        OnInsertCapValueEntryOnAfterInsertValueEntryRelation(ValueEntry, ItemJournalLine, TempValueEntryRelation);        if (ItemJournalLine."Item Shpt. Entry No." <> 0) and           (ValueEntryType = ItemJournalLine."Value Entry Type"::"Direct Cost")        then begin            CapLedgEntry."Invoiced Quantity" := CapLedgEntry."Invoiced Quantity" + ItemJournalLine."Invoiced Quantity";            CapLedgEntry."Completely Invoiced" := CapLedgEntry."Invoiced Quantity" = CapLedgEntry.Quantity;            OnInsertCapValueEntryOnBeforeCapLedgEntryModify(CapLedgEntry, ItemJournalLine);            CapLedgEntry.Modify();        end;        OnInsertCapValueEntryOnAfterUpdateCapLedgEntry(ValueEntry, ItemJournalLine);    end;    /// <summary>    /// Posts the current item journal line in the global ItemJnlLine buffer, creating item ledger, value and application entries.    /// It checks if the quantity and invoiced quantity of the item journal line are different. If they are,     /// it tests if the invoiced quantity is zero and raises an error otherwise.    /// Inserts an item ledger entry and a value entry from the item journal line information.    /// </summary>    procedure ItemQtyPosting()    var        IsReserved: Boolean;        InsertItemLedgEntryNeeded: Boolean;        IsHandled: Boolean;    begin        OnBeforeItemQtyPosting(ItemJnlLine, CalledFromAdjustment, IsHandled);        if isHandled then            exit;        if ItemJnlLine.Quantity <> ItemJnlLine."Invoiced Quantity" then            ItemJnlLine.TestField("Invoiced Quantity", 0);        ItemJnlLine.TestField("Item Shpt. Entry No.", 0);        InitItemLedgEntry(GlobalItemLedgEntry);        InitValueEntry(GlobalValueEntry, GlobalItemLedgEntry);        SetRemainingQuantityAndFlags();        if GlobalItemLedgEntry.Quantity > 0 then            if GlobalItemLedgEntry."Entry Type" <> GlobalItemLedgEntry."Entry Type"::Transfer then                IsReserved :=                  ItemJnlLineReserve.TransferItemJnlToItemLedgEntry(                    ItemJnlLine, GlobalItemLedgEntry, ItemJnlLine."Quantity (Base)", true);        OnItemQtyPostingOnBeforeApplyItemLedgEntry(ItemJnlLine, GlobalItemLedgEntry);        ApplyItemLedgEntry(GlobalItemLedgEntry, OldItemLedgEntry, GlobalValueEntry, false);        UpdateReservationEntryForNonInventoriableItem();        CheckApplFromInProduction(GlobalItemLedgEntry, ItemJnlLine."Applies-from Entry");        AutoTrack(GlobalItemLedgEntry, IsReserved);        if (ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Transfer) and AverageTransfer then            InsertTransferEntry(GlobalItemLedgEntry, OldItemLedgEntry, TotalAppliedQty);        OnItemQtyPostingOnAfterInsertTransferEntry(            ItemJnlLine, AverageTransfer, GlobalItemLedgEntry, OldItemLedgEntry, TotalAppliedQty, TempItemEntryRelation, GlobalValueEntry);        if ItemJnlLine."Entry Type" in [ItemJnlLine."Entry Type"::"Assembly Output", ItemJnlLine."Entry Type"::"Assembly Consumption"] then            InsertAsmItemEntryRelation(GlobalItemLedgEntry);        InsertItemLedgEntryNeeded := (not ItemJnlLine."Phys. Inventory") or (ItemJnlLine.Quantity <> 0);        OnItemQtyPostingOnAfterCalcInsertItemLedgEntryNeeded(ItemJnlLine, InsertItemLedgEntryNeeded);        if InsertItemLedgEntryNeeded then begin            InsertItemLedgEntry(GlobalItemLedgEntry, false);            OnItemQtyPostingOnBeforeInsertApplEntry(GlobalItemLedgEntry, ItemJnlLine);            if GlobalItemLedgEntry.Positive then                InsertApplEntry(                  GlobalItemLedgEntry."Entry No.", GlobalItemLedgEntry."Entry No.",                  ItemJnlLine."Applies-from Entry", 0, GlobalItemLedgEntry."Posting Date",                  GlobalItemLedgEntry.Quantity, true);            OnItemQtyPostingOnAfterInsertApplEntry(ItemJnlLine, TempSplitItemJnlLine, GlobalItemLedgEntry);        end;        OnAfterItemQtyPosting(ItemJnlLine);    end;    local procedure SetRemainingQuantityAndFlags()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetRemainingQuantityAndFlags(ItemJnlLine, Item, GlobalItemLedgEntry, IsHandled);        if IsHandled then            exit;        if Item.Type = Item.Type::Inventory then begin            GlobalItemLedgEntry."Remaining Quantity" := GlobalItemLedgEntry.Quantity;            GlobalItemLedgEntry.Open := GlobalItemLedgEntry."Remaining Quantity" <> 0;        end else begin            GlobalItemLedgEntry."Remaining Quantity" := 0;            GlobalItemLedgEntry.Open := false;        end;        GlobalItemLedgEntry.Positive := GlobalItemLedgEntry.Quantity > 0;        if GlobalItemLedgEntry."Entry Type" = GlobalItemLedgEntry."Entry Type"::Transfer then            GlobalItemLedgEntry."Completely Invoiced" := true;    end;    local procedure CheckRunItemValuePosting()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckRunItemValuePosting(ItemJnlLine, IsHandled);        if IsHandled then            exit;        if ((ItemJnlLine.Quantity <> 0) or (ItemJnlLine."Invoiced Quantity" <> 0)) and                not (ItemJnlLine.Adjustment and (ItemJnlLine.Amount = 0) and (ItemJnlLine."Amount (ACY)" = 0))        then            ItemValuePosting();    end;    local procedure CheckIfItemIsBlocked()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckIfItemIsBlocked(ItemJnlLine, CalledFromAdjustment, IsHandled);        if IsHandled then            exit;        if not CalledFromAdjustment then            ItemJnlLine.DisplayErrorIfItemIsBlocked(Item);        Item.CheckBlockedByApplWorksheet();    end;    local procedure CheckIfItemVariantIsBlocked()    begin        if not CalledFromAdjustment then            ItemJnlLine.DisplayErrorIfItemVariantIsBlocked(ItemVariant);    end;    /// <summary>    /// Posts balance of expected cost reversal if it's expected by item's costing method.    /// </summary>    /// <remarks>    /// If a balance is expected from a cost reversal based on the item's costing method and the properties of the     /// item journal line then the procedure inserts a balance expected cost reversal entry for a value entry.    /// </remarks>    procedure ItemValuePosting()    var        xValueEntryNo: Integer;        IsCostNotTracedDirectly: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeItemValuePosting(ItemJnlLine, IsHandled);        if IsHandled then            exit;        if (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and           (ItemJnlLine."Item Charge No." = '') and           not ItemJnlLine.Adjustment        then begin            IsHandled := false;            OnItemValuePostingOnBeforeValuateAvgEntry(ItemJnlLine, Item, GlobalValueEntry, IsHandled);            if not IsHandled then                if (ItemJnlLine.Quantity = 0) and (ItemJnlLine."Invoiced Quantity" <> 0) then begin                    if (GlobalValueEntry."Invoiced Quantity" < 0) and                       (Item."Costing Method" = Item."Costing Method"::Average)                    then                        ValuateAppliedAvgEntry(GlobalValueEntry, Item);                end else                    if (GlobalValueEntry."Valued Quantity" < 0) and (ItemJnlLine."Entry Type" <> ItemJnlLine."Entry Type"::Transfer) then                        if Item."Costing Method" = Item."Costing Method"::Average then                            ValuateAppliedAvgEntry(GlobalValueEntry, Item);        end;        IsHandled := false;        OnItemValuePostingOnBeforeInsertValueEntry(ItemJnlLine, IsHandled);        if not IsHandled then            InsertValueEntry(GlobalValueEntry, GlobalItemLedgEntry, false);        xValueEntryNo := ValueEntryNo;        OnItemValuePostingOnAfterInsertValueEntry(GlobalValueEntry, GlobalItemLedgEntry, ValueEntryNo);        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");        IsCostNotTracedDirectly := (ItemJnlLine."Value Entry Type" <> ItemJnlLine."Value Entry Type"::"Direct Cost") or (ItemJnlLine."Item Charge No." <> '');        OnItemValuePostingOnAfterCalcIsCostNotTracedDirectly(ItemJnlLine, IsCostNotTracedDirectly);        if IsCostNotTracedDirectly then begin            if (ItemJnlLine."Value Entry Type" <> ItemJnlLine."Value Entry Type"::Rounding) and (not ItemJnlLine.Adjustment) then begin                if GlobalItemLedgEntry.Positive then                    GlobalItemLedgEntry.Modify();                IsHandled := false;                xValueEntryNo := ValueEntryNo;                OnItemValuePostingOnBeforeInsertOHValueEntry(ItemJnlLine, GlobalValueEntry, GlobalItemLedgEntry, ValueEntryNo, IsHandled, VarianceAmount, VarianceAmountACY, OverheadAmount, OverheadAmountACY, VarianceRequired);                ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");                if not IsHandled then                    if ((GlobalValueEntry."Valued Quantity" > 0) or                        ((ItemJnlLine."Applies-to Entry" <> 0) and (ItemJnlLine."Entry Type" in [ItemJnlLine."Entry Type"::Purchase, ItemJnlLine."Entry Type"::"Assembly Output"]))) and                       (OverheadAmount <> 0)                    then                        InsertOHValueEntry(GlobalValueEntry, OverheadAmount, OverheadAmountACY);                if (Item."Costing Method" = Item."Costing Method"::Standard) and                   (ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Purchase) and                   (GlobalValueEntry."Entry Type" <> GlobalValueEntry."Entry Type"::Revaluation)                then                    InsertVarValueEntry(                      GlobalValueEntry,                      -GlobalValueEntry."Cost Amount (Actual)" + OverheadAmount,                      -(GlobalValueEntry."Cost Amount (Actual) (ACY)" + OverheadAmountACY));            end;        end else begin            if IsBalanceExpectedCostFromRev(ItemJnlLine) then                InsertBalanceExpCostRevEntry(GlobalValueEntry);            IsHandled := false;            xValueEntryNo := ValueEntryNo;            OnItemValuePostingOnBeforeInsertOHValueEntry(ItemJnlLine, GlobalValueEntry, GlobalItemLedgEntry, ValueEntryNo, IsHandled, VarianceAmount, VarianceAmountACY, OverheadAmount, OverheadAmountACY, VarianceRequired);            ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");            if not IsHandled then                if ((GlobalValueEntry."Valued Quantity" > 0) or                    ((ItemJnlLine."Applies-to Entry" <> 0) and (ItemJnlLine."Entry Type" in [ItemJnlLine."Entry Type"::Purchase, ItemJnlLine."Entry Type"::"Assembly Output"]))) and                   (OverheadAmount <> 0)                then                    InsertOHValueEntry(GlobalValueEntry, OverheadAmount, OverheadAmountACY);            if ((GlobalValueEntry."Valued Quantity" > 0) or (ItemJnlLine."Applies-to Entry" <> 0)) and               (ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Purchase) and               (Item."Costing Method" = Item."Costing Method"::Standard) and               (Round(VarianceAmount, GLSetup."Amount Rounding Precision") <> 0) or               VarianceRequired            then                InsertVarValueEntry(GlobalValueEntry, VarianceAmount, VarianceAmountACY);        end;        IsHandled := false;        OnItemValuePostingOnBeforeUpdateItemApplnEntry(ItemJnlLine, GlobalValueEntry, GlobalItemLedgEntry, IsHandled);        if not IsHandled then            if (GlobalValueEntry."Valued Quantity" < 0) and               (GlobalItemLedgEntry.Quantity = GlobalItemLedgEntry."Invoiced Quantity")            then                UpdateItemApplnEntry(GlobalValueEntry."Item Ledger Entry No.", ItemJnlLine."Posting Date");        OnAfterItemValuePosting(GlobalValueEntry, ItemJnlLine, Item);    end;#if not CLEAN27    /// <summary>    /// Posts the consumption of the component in a production order.     /// </summary>    /// <param name="ProdOrder">Production order being posted.</param>    /// <param name="ProdOrderLine">Production order line being posted.</param>    /// <param name="ProdOrderComp">Production order component to post.</param>    /// <param name="ProdOrderRoutingLine">Production order routing line. This record is only used on events.</param>    /// <param name="OldItemJnlLine">Previous item journal line from which new one will be initialized.</param>    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    procedure PostFlushedConsumption(ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; OldItemJnlLine: Record "Item Journal Line")    var        MfgItemJnlPostLine: Codeunit "Mfg. Item Jnl.-Post Line";        ItemJnlPostLine: Variant;    begin        ItemJnlPostLine := this;        MfgItemJnlPostLine.PostFlushedConsumption(            ItemJnlLine, ProdOrder, ProdOrderLine, ProdOrderComp, ProdOrderRoutingLine, OldItemJnlLine, ItemJnlPostLine);    end;#endif    internal procedure PostFlushedConsumptionItemJnlLine(var ItemJnlLine2: Record "Item Journal Line"; CombinedDimSetID: Integer)    var#if not CLEAN27        ProdOrder: Record Microsoft.Manufacturing.Document."Production Order";        ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line";        ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component";#endif        PostItemJnlLine: Boolean;        DimsAreTaken: Boolean;        TrackingSpecExists: Boolean;    begin        PrepareItem(ItemJnlLine2);        TrackingSpecExists := ItemTrackingMgt.RetrieveItemTracking(ItemJnlLine2, TempTrackingSpecification);        OnPostFlushedConsumptionItemJnlLineOnBeforeSetupSplitJnlLine(ItemJnlLine2, TempTrackingSpecification, TrackingSpecExists);#if not CLEAN27        ProdOrder.Get(ProdOrder.Status::Released, ItemJnlLine2."Order No.");        ProdOrderLine.Get(ProdOrder.Status::Released, ItemJnlLine2."Order No.", ItemJnlLine2."Order Line No.");        ProdOrderComp.Get(ProdOrder.Status::Released, ItemJnlLine2."Order No.", ItemJnlLine2."Order Line No.", ItemJnlLine2."Prod. Order Comp. Line No.");        OnPostFlushedConsumpOnBeforeSetupSplitJnlLine(ItemJnlLine2, ProdOrder, ProdOrderLine, ProdOrderComp, TempTrackingSpecification, TrackingSpecExists);#endif        PostItemJnlLine := SetupSplitJnlLine(ItemJnlLine2, TrackingSpecExists);        while SplitItemJnlLine(ItemJnlLine2, PostItemJnlLine) do begin            ItemJnlLine2.CheckTrackingIfRequiredNotBlank(GlobalItemTrackingSetup);            if not DimsAreTaken then begin                ItemJnlLine2."Dimension Set ID" := CombinedDimSetID;                OnPostFlushedConsumptionItemJnlLineOnAfterSetDimensionSetID(ItemJnlLine);#if not CLEAN27                OnPostFlushedConsumptionOnAfterSetDimensionSetID(ItemJnlLine, ProdOrderLine);#endif                DimsAreTaken := true;            end;            ItemJnlCheckLine.RunCheck(ItemJnlLine2);            ProdOrderCompModified := true;            ItemJnlLine2.Quantity := ItemJnlLine2."Quantity (Base)";            ItemJnlLine2."Invoiced Quantity" := ItemJnlLine2."Invoiced Qty. (Base)";            QtyPerUnitOfMeasure := ItemJnlLine2."Qty. per Unit of Measure";            ItemJnlLine2."Unit Amount" := Round(                ItemJnlLine2."Unit Amount" / QtyPerUnitOfMeasure, GLSetup."Unit-Amount Rounding Precision");            ItemJnlLine2."Unit Cost" := Round(                ItemJnlLine2."Unit Cost" / QtyPerUnitOfMeasure, GLSetup."Unit-Amount Rounding Precision");            ItemJnlLine2."Unit Cost (ACY)" := Round(                ItemJnlLine2."Unit Cost (ACY)" / QtyPerUnitOfMeasure, Currency."Unit-Amount Rounding Precision");            PostConsumption(ItemJnlLine2);        end;    end;    /// <summary>    /// Updates the unit cost on item and SKU for the last direct cost from the value entry.    /// </summary>    /// <param name="ValueEntry">Value entry to calculate unit cost from.</param>    procedure UpdateUnitCost(ValueEntry: Record "Value Entry")    var        ItemCostMgt: Codeunit ItemCostManagement;        LastDirectCost: Decimal;        TotalAmount: Decimal;        IsHandled: Boolean;        UpdateSKU: Boolean;    begin        IsHandled := false;        OnBeforeUpdateUnitCost(ValueEntry, IsHandled, ItemJnlLine);        if IsHandled then            exit;        if (ValueEntry."Valued Quantity" > 0) and not (ValueEntry."Expected Cost" or ItemJnlLine.Adjustment) then begin            Item.ReadIsolation(IsolationLevel::UpdLock);            if not Item.Find() then                exit;            if ValueEntry.IsInbound() and               ((ValueEntry."Cost Amount (Actual)" + ValueEntry."Discount Amount" > 0) or Item.IsNonInventoriableType()) and               (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and               (ItemJnlLine."Item Charge No." = '') and not Item."Inventory Value Zero"            then begin                TotalAmount := ItemJnlLine.Amount + ItemJnlLine."Discount Amount";                IsHandled := false;                OnUpdateUnitCostOnBeforeCalculateLastDirectCost(TotalAmount, ItemJnlLine, ValueEntry, Item, IsHandled);                if not IsHandled then                    LastDirectCost := Round(TotalAmount / ValueEntry."Valued Quantity", GLSetup."Unit-Amount Rounding Precision")            end;            if ValueEntry."Drop Shipment" then begin                if LastDirectCost <> 0 then begin                    Item."Last Direct Cost" := LastDirectCost;                    OnUpdateUnitCostOnAfterAssignLastDirectCost(ValueEntry, Item, LastDirectCost);                    Item.Modify();                    ItemCostMgt.SetProperties(false, ValueEntry."Invoiced Quantity");                    ItemCostMgt.FindUpdateUnitCostSKU(Item, ValueEntry."Location Code", ValueEntry."Variant Code", true, LastDirectCost);                end;            end else begin                UpdateSKU := true;                OnUpdateUnitCostOnBeforeUpdateUnitCost(ItemJnlLine, ValueEntry, Item, UpdateSKU);                ItemCostMgt.SetProperties(false, ValueEntry."Invoiced Quantity");                ItemCostMgt.UpdateUnitCost(Item, ValueEntry."Location Code", ValueEntry."Variant Code", LastDirectCost, 0, UpdateSKU, true, false, 0);            end;        end;        OnAfterUpdateUnitCost(ValueEntry, LastDirectCost, ItemJnlLine, Item);    end;    /// <summary>    /// Unapplies the provided item application entry.    /// </summary>    /// <remarks>    /// Entries applied to an outbound transfer and drop shipment order cannot be unapplied.    /// </remarks>    /// <param name="ItemApplnEntry">Item application entry to unapply.</param>    procedure UnApply(ItemApplnEntry: Record "Item Application Entry")    var        ItemLedgEntry1: Record "Item Ledger Entry";        ItemLedgEntry2: Record "Item Ledger Entry";        CostItemLedgEntry: Record "Item Ledger Entry";        InventoryPeriod: Record "Inventory Period";        Valuationdate: Date;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUnApply(ItemApplnEntry, IsHandled);        if IsHandled then            exit;        if not InventoryPeriod.IsValidDate(ItemApplnEntry."Posting Date") then            InventoryPeriod.ShowError(ItemApplnEntry."Posting Date");        // If we can't get both entries then the application is not a real application or a date compression might have been done        ItemLedgEntry1.Get(ItemApplnEntry."Inbound Item Entry No.");        ItemLedgEntry2.Get(ItemApplnEntry."Outbound Item Entry No.");        if ItemApplnEntry."Item Ledger Entry No." = ItemApplnEntry."Inbound Item Entry No." then            CheckItemCorrection(ItemLedgEntry1);        if ItemApplnEntry."Item Ledger Entry No." = ItemApplnEntry."Outbound Item Entry No." then            CheckItemCorrection(ItemLedgEntry2);        if ItemLedgEntry1."Drop Shipment" and ItemLedgEntry2."Drop Shipment" then            Error(Text024);        if ItemLedgEntry2."Entry Type" = ItemLedgEntry2."Entry Type"::Transfer then            Error(Text023);        ItemApplnEntry.TestField("Transferred-from Entry No.", 0);        // We won't allow deletion of applications for deleted items        GetItem(ItemLedgEntry1."Item No.", true);        CostItemLedgEntry.Get(ItemApplnEntry.CostReceiver()); // costreceiver        OnUnApplyOnBeforeUpdateItemLedgerEntries(ItemLedgEntry1, ItemLedgEntry2, ItemApplnEntry);        if ItemLedgEntry1."Applies-to Entry" = ItemLedgEntry2."Entry No." then            ItemLedgEntry1."Applies-to Entry" := 0;        if ItemLedgEntry2."Applies-to Entry" = ItemLedgEntry1."Entry No." then            ItemLedgEntry2."Applies-to Entry" := 0;        // only if real/quantity application        if not ItemApplnEntry.CostApplication() then begin            ItemLedgEntry1."Remaining Quantity" := ItemLedgEntry1."Remaining Quantity" - ItemApplnEntry.Quantity;            ItemLedgEntry1.Open := ItemLedgEntry1."Remaining Quantity" <> 0;            ItemLedgEntry1.Modify();            ItemLedgEntry2."Remaining Quantity" := ItemLedgEntry2."Remaining Quantity" + ItemApplnEntry.Quantity;            ItemLedgEntry2.Open := ItemLedgEntry2."Remaining Quantity" <> 0;            ItemLedgEntry2.Modify();        end else begin            ItemLedgEntry2."Shipped Qty. Not Returned" := ItemLedgEntry2."Shipped Qty. Not Returned" - Abs(ItemApplnEntry.Quantity);            if Abs(ItemLedgEntry2."Shipped Qty. Not Returned") > Abs(ItemLedgEntry2.Quantity) then                ItemLedgEntry2.FieldError("Shipped Qty. Not Returned", Text004); // Assert - should never happen            ItemLedgEntry2.Modify();            OnUnApplyOnBeforeInsertApplEntry(ItemApplnEntry);            // If cost application we need to insert a 0 application instead if there is none before            if ItemApplnEntry.Quantity > 0 then                if not ZeroApplication(ItemApplnEntry."Item Ledger Entry No.") then                    InsertApplEntry(                      ItemApplnEntry."Item Ledger Entry No.", ItemApplnEntry."Inbound Item Entry No.",                      0, 0, ItemApplnEntry."Posting Date", ItemApplnEntry.Quantity, true);        end;        if Item."Costing Method" = Item."Costing Method"::Average then            if not ItemApplnEntry.Fixed() then                UpdateValuedByAverageCost(CostItemLedgEntry."Entry No.", true);        ItemApplnEntry.InsertHistory();        TouchEntry(ItemApplnEntry."Inbound Item Entry No.");        SaveTouchedEntry(ItemApplnEntry."Inbound Item Entry No.", true);        if ItemApplnEntry."Outbound Item Entry No." <> 0 then begin            TouchEntry(ItemApplnEntry."Outbound Item Entry No.");            SaveTouchedEntry(ItemApplnEntry."Inbound Item Entry No.", false);        end;        OnUnApplyOnBeforeItemApplnEntryDelete(ItemApplnEntry);        ItemApplnEntry.Delete();        Valuationdate := GetMaxAppliedValuationdate(CostItemLedgEntry);        if Valuationdate = 0D then            Valuationdate := CostItemLedgEntry."Posting Date"        else            Valuationdate := max(CostItemLedgEntry."Posting Date", Valuationdate);        SetValuationDateAllValueEntrie(CostItemLedgEntry."Entry No.", Valuationdate, false);        UpdateLinkedValuationUnapply(Valuationdate, CostItemLedgEntry."Entry No.", CostItemLedgEntry.Positive);    end;    procedure UnApplyDropShipment(ItemApplicationEntry: Record "Item Application Entry"; NewItemShptEntryNo: Integer)    var        ItemLedgerEntry1: Record "Item Ledger Entry";        ItemLedgerEntry2: Record "Item Ledger Entry";        CostItemLedgerEntry: Record "Item Ledger Entry";        InventoryPeriod: Record "Inventory Period";        ValuationDate: Date;    begin        if not InventoryPeriod.IsValidDate(ItemApplicationEntry."Posting Date") then            InventoryPeriod.ShowError(ItemApplicationEntry."Posting Date");        ItemLedgerEntry1.Get(ItemApplicationEntry."Inbound Item Entry No.");        ItemLedgerEntry2.Get(ItemApplicationEntry."Outbound Item Entry No.");        if (not ItemLedgerEntry1."Drop Shipment") or (not ItemLedgerEntry2."Drop Shipment") then            Error(CanOnlyBeUsedForDropShipmentErr);        if ItemApplicationEntry."Item Ledger Entry No." = ItemApplicationEntry."Inbound Item Entry No." then            CheckItemCorrection(ItemLedgerEntry1);        if ItemApplicationEntry."Item Ledger Entry No." = ItemApplicationEntry."Outbound Item Entry No." then            CheckItemCorrection(ItemLedgerEntry2);        if ItemLedgerEntry2."Entry Type" = ItemLedgerEntry2."Entry Type"::Transfer then            Error(Text023);        ItemApplicationEntry.TestField("Transferred-from Entry No.", 0);        GetItem(ItemLedgerEntry1."Item No.", true);        CostItemLedgerEntry.Get(ItemApplicationEntry.CostReceiver());        if ItemLedgerEntry1."Applies-to Entry" = ItemLedgerEntry2."Entry No." then            ItemLedgerEntry1."Applies-to Entry" := 0;        if not ItemApplicationEntry.CostApplication() then begin            ItemLedgerEntry1."Remaining Quantity" := ItemLedgerEntry1."Remaining Quantity" - ItemApplicationEntry.Quantity;            ItemLedgerEntry1.Open := ItemLedgerEntry1."Remaining Quantity" <> 0;            ItemLedgerEntry1.Modify();        end else            Error(DropShipmentCostApplicationsCannotBeUnappliedErr);        if Item."Costing Method" = Item."Costing Method"::Average then            if not ItemApplicationEntry.Fixed() then                UpdateValuedByAverageCost(CostItemLedgerEntry."Entry No.", true);        InsertApplEntry(            ItemApplicationEntry."Item Ledger Entry No.",            NewItemShptEntryNo,            ItemApplicationEntry."Item Ledger Entry No.",            0,            ItemApplicationEntry."Posting Date",            ItemApplicationEntry.Quantity,            true);        ItemApplicationEntry.InsertHistory();        TouchEntry(ItemApplicationEntry."Inbound Item Entry No.");        SaveTouchedEntry(ItemApplicationEntry."Inbound Item Entry No.", true);        if ItemApplicationEntry."Outbound Item Entry No." <> 0 then begin            TouchEntry(ItemApplicationEntry."Outbound Item Entry No.");            SaveTouchedEntry(ItemApplicationEntry."Inbound Item Entry No.", false);        end;        ItemApplicationEntry.Delete();        ValuationDate := GetMaxAppliedValuationdate(CostItemLedgerEntry);        if ValuationDate = 0D then            ValuationDate := CostItemLedgerEntry."Posting Date"        else            ValuationDate := max(CostItemLedgerEntry."Posting Date", ValuationDate);        SetValuationDateAllValueEntrie(CostItemLedgerEntry."Entry No.", ValuationDate, false);        UpdateLinkedValuationUnapply(ValuationDate, CostItemLedgerEntry."Entry No.", CostItemLedgerEntry.Positive);    end;    /// <summary>    /// Reapplies item ledger entries.    /// </summary>    /// <param name="ItemLedgEntry">Item ledger entry to reaplly.</param>    /// <param name="ApplyWith">Apply to item ledger entry no.</param>    procedure ReApply(ItemLedgEntry: Record "Item Ledger Entry"; ApplyWith: Integer)    var        ItemLedgEntry2: Record "Item Ledger Entry";        ValueEntry: Record "Value Entry";        InventoryPeriod: Record "Inventory Period";        CostApplication: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeReApply(ItemLedgEntry, ApplyWith, IsHandled);        if IsHandled then            exit;        GetItem(ItemLedgEntry."Item No.", true);        if not InventoryPeriod.IsValidDate(ItemLedgEntry."Posting Date") then            InventoryPeriod.ShowError(ItemLedgEntry."Posting Date");        GlobalItemTrackingCode.Code := Item."Item Tracking Code";        OnReApplyOnBeforeGetItemTrackingSetup(Item, GlobalItemTrackingCode);        ItemTrackingMgt.GetItemTrackingSetup(            GlobalItemTrackingCode, ItemJnlLine."Entry Type",            ItemJnlLine.Signed(ItemJnlLine."Quantity (Base)") > 0, GlobalItemTrackingSetup);        TotalAppliedQty := 0;        CostApplication := false;        if ApplyWith <> 0 then begin            ItemLedgEntry2.Get(ApplyWith);            if ItemLedgEntry2.Quantity > 0 then begin                // Switch around so ItemLedgEntry is positive and ItemLedgEntry2 is negative                OldItemLedgEntry := ItemLedgEntry;                ItemLedgEntry := ItemLedgEntry2;                ItemLedgEntry2 := OldItemLedgEntry;            end;            OnReApplyOnBeforeStartApply(ItemLedgEntry, ItemLedgEntry2);            if not ((ItemLedgEntry.Quantity > 0) and // not(Costprovider(ItemLedgEntry))                    ((ItemLedgEntry."Entry Type" = ItemLedgEntry2."Entry Type"::Purchase) or                     (ItemLedgEntry."Entry Type" = ItemLedgEntry2."Entry Type"::"Positive Adjmt.") or                     (ItemLedgEntry."Entry Type" = ItemLedgEntry2."Entry Type"::Output) or                     (ItemLedgEntry."Entry Type" = ItemLedgEntry2."Entry Type"::"Assembly Output"))                    )            then                CostApplication := true;            if (ItemLedgEntry."Remaining Quantity" <> 0) and (ItemLedgEntry2."Remaining Quantity" <> 0) then                CostApplication := false;            OnReApplyOnBeforeCostApply(ItemLedgEntry, ItemLedgEntry2, CostApplication);            if CostApplication then                CostApply(ItemLedgEntry, ItemLedgEntry2)            else begin                CreateItemJnlLineFromEntry(ItemLedgEntry2, ItemLedgEntry2."Remaining Quantity", ItemJnlLine);                if ApplyWith = ItemLedgEntry2."Entry No." then                    ItemLedgEntry2."Applies-to Entry" := ItemLedgEntry."Entry No."                else                    ItemLedgEntry2."Applies-to Entry" := ApplyWith;                ItemJnlLine."Applies-to Entry" := ItemLedgEntry2."Applies-to Entry";                GlobalItemLedgEntry := ItemLedgEntry2;                ApplyItemLedgEntry(ItemLedgEntry2, OldItemLedgEntry, ValueEntry, false);                TouchItemEntryCost(ItemLedgEntry2, false);                ItemLedgEntry2.Modify();                EnsureValueEntryLoaded(ValueEntry, ItemLedgEntry2);                IsHandled := false;                OnReApplyOnBeforeUpdateLinkedValuationDate(ValueEntry, IsHandled);                if not IsHandled then begin                    GetValuationDate(ValueEntry, ItemLedgEntry);                    UpdateLinkedValuationDate(ValueEntry."Valuation Date", GlobalItemLedgEntry."Entry No.", GlobalItemLedgEntry.Positive);                end;            end;            if ItemApplnEntry.Fixed() and (ItemApplnEntry.CostReceiver() <> 0) then                if GetItem(ItemLedgEntry."Item No.", false) then                    if Item."Costing Method" = Item."Costing Method"::Average then                        UpdateValuedByAverageCost(ItemApplnEntry.CostReceiver(), false);        end else begin  // ApplyWith is 0            ItemLedgEntry."Applies-to Entry" := ApplyWith;            IsHandled := false;            OnReApplyOnBeforeCreateItemJnlLineFromEntryApplyWithZero(ItemLedgEntry, ItemJnlLine, IsHandled);            if not IsHandled then                CreateItemJnlLineFromEntry(ItemLedgEntry, ItemLedgEntry."Remaining Quantity", ItemJnlLine);            ItemJnlLine."Applies-to Entry" := ItemLedgEntry."Applies-to Entry";            GlobalItemLedgEntry := ItemLedgEntry;            ApplyItemLedgEntry(ItemLedgEntry, OldItemLedgEntry, ValueEntry, false);            TouchItemEntryCost(ItemLedgEntry, false);            ItemLedgEntry.Modify();            EnsureValueEntryLoaded(ValueEntry, ItemLedgEntry);            IsHandled := false;            OnReApplyOnBeforeUpdateLinkedValuationDate(ValueEntry, IsHandled);            if not IsHandled then begin                GetValuationDate(ValueEntry, ItemLedgEntry);                UpdateLinkedValuationDate(ValueEntry."Valuation Date", GlobalItemLedgEntry."Entry No.", GlobalItemLedgEntry.Positive);            end;        end;    end;    local procedure CostApply(var ItemLedgEntry: Record "Item Ledger Entry"; ItemLedgEntry2: Record "Item Ledger Entry")    var        ApplyWithItemLedgEntry: Record "Item Ledger Entry";        ValueEntry: Record "Value Entry";    begin        if ItemLedgEntry.Quantity > 0 then begin            GlobalItemLedgEntry := ItemLedgEntry;            ApplyWithItemLedgEntry := ItemLedgEntry2;        end        else begin            GlobalItemLedgEntry := ItemLedgEntry2;            ApplyWithItemLedgEntry := ItemLedgEntry;        end;        if not ItemApplnEntry.CheckIsCyclicalLoop(ApplyWithItemLedgEntry, GlobalItemLedgEntry) then begin            CreateItemJnlLineFromEntry(GlobalItemLedgEntry, GlobalItemLedgEntry.Quantity, ItemJnlLine);            OnCostApplyOnBeforeInsertApplEntry(GlobalItemLedgEntry, ApplyWithItemLedgEntry);            InsertApplEntry(              GlobalItemLedgEntry."Entry No.", GlobalItemLedgEntry."Entry No.",              ApplyWithItemLedgEntry."Entry No.", 0, GlobalItemLedgEntry."Posting Date",              GlobalItemLedgEntry.Quantity, true);            UpdateOutboundItemLedgEntry(ApplyWithItemLedgEntry."Entry No.");            OldItemLedgEntry.Get(ApplyWithItemLedgEntry."Entry No.");            EnsureValueEntryLoaded(ValueEntry, GlobalItemLedgEntry);            ItemJnlLine."Applies-from Entry" := ApplyWithItemLedgEntry."Entry No.";            GetAppliedFromValues(ValueEntry);            SetValuationDateAllValueEntrie(GlobalItemLedgEntry."Entry No.", ValueEntry."Valuation Date", false);            UpdateLinkedValuationDate(ValueEntry."Valuation Date", GlobalItemLedgEntry."Entry No.", GlobalItemLedgEntry.Positive);            TouchItemEntryCost(ItemLedgEntry2, false);        end;    end;    local procedure ZeroApplication(EntryNo: Integer): Boolean    var        Application: Record "Item Application Entry";    begin        Application.SetCurrentKey("Inbound Item Entry No.", "Item Ledger Entry No.");        Application.SetRange("Item Ledger Entry No.", EntryNo);        Application.SetRange("Inbound Item Entry No.", EntryNo);        Application.SetRange("Outbound Item Entry No.", 0);        exit(not Application.IsEmpty);    end;    /// <summary>    /// Applies an item ledger entry to another item ledger entry.    /// </summary>    /// <remarks>    /// Usually used in inventory management where you want to match an incoming item ledger entry (like a purchase)     /// with an outgoing item ledger entry (like a sale).    /// </remarks>    /// <param name="ItemLedgEntry">    /// Item Ledger entry to apply. If this is a cost application, the entry is marked as applied entry to adjust.    /// </param>    /// <param name="OldItemLedgEntry"> Return value: Item ledger entry the to-apply entry is applied to. </param>    /// <param name="ValueEntry">Return value: Value entry with updated valuation date.</param>    /// <param name="CausedByTransfer">Is caused by a transfer.</param>    procedure ApplyItemLedgEntry(var ItemLedgEntry: Record "Item Ledger Entry"; var OldItemLedgEntry: Record "Item Ledger Entry"; var ValueEntry: Record "Value Entry"; CausedByTransfer: Boolean)    var        ItemLedgEntry2: Record "Item Ledger Entry";        OldValueEntry: Record "Value Entry";        ReservEntry: Record "Reservation Entry";        ReservEntry2: Record "Reservation Entry";        AppliesFromItemLedgEntry: Record "Item Ledger Entry";        EntryFindMethod: Text[1];        AppliedQty: Decimal;        FirstReservation: Boolean;        FirstApplication: Boolean;        StartApplication: Boolean;        UseReservationApplication: Boolean;        IsHandled: Boolean;        SkipReservationCheck: Boolean;    begin        OnBeforeApplyItemLedgEntry(ItemLedgEntry, OldItemLedgEntry, ValueEntry, CausedByTransfer, IsHandled, ItemJnlLine, ItemApplnEntryNo);        if IsHandled then            exit;        if (ItemLedgEntry."Remaining Quantity" = 0) or           (ItemLedgEntry."Drop Shipment" and (ItemLedgEntry."Applies-to Entry" = 0)) or           ((Item."Costing Method" = Item."Costing Method"::Specific) and ItemLedgEntry.Positive) or           (ItemJnlLine."Direct Transfer" and (ItemLedgEntry."Location Code" = '') and ItemLedgEntry.Positive)        then            exit;        Clear(OldItemLedgEntry);        ItemLedgEntry2.ReadIsolation(IsolationLevel::ReadUnCommitted);        FirstReservation := true;        FirstApplication := true;        StartApplication := false;        repeat            if ItemJnlLine."Assemble to Order" then                VerifyItemJnlLineAsembleToOrder(ItemJnlLine)            else                VerifyItemJnlLineApplication(ItemJnlLine, ItemLedgEntry);            if not CausedByTransfer and not PostponeReservationHandling then begin                if Item."Costing Method" = Item."Costing Method"::Specific then                    ItemJnlLine.TestField("Serial No.");                SkipReservationCheck := //posting together with PO                    (ItemJnlLine."Document Type" = ItemJnlLine."Document Type"::"Purchase Receipt")                    and (ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::"Negative Adjmt.")                    and (ItemJnlLine."Job No." <> '');                IsHandled := false;                OnApplyItemLedgEntryOnBeforeFirstReservationSetFilters(ItemJnlLine, StartApplication, FirstReservation, IsHandled);                if not IsHandled then                    if FirstReservation then begin                        FirstReservation := false;                        ReservEntry.Reset();                        ReservEntry.SetCurrentKey(                          "Source ID", "Source Ref. No.", "Source Type", "Source Subtype",                          "Source Batch Name", "Source Prod. Order Line", "Reservation Status");                        ReservEntry.SetRange("Reservation Status", ReservEntry."Reservation Status"::Reservation);                        ItemJnlLine.SetReservationFilters(ReservEntry);                        ReservEntry.SetRange("Item No.", ItemJnlLine."Item No.");                    end;                if TempTrackingSpecification.IsEmpty() then                    if ItemJnlLine."Document Type" = ItemJnlLine."Document Type"::"Direct Transfer" then                        if ItemLedgEntry.Quantity < 0 then                            ReservEntry.SetRange(Positive, false)                        else                            ReservEntry.SetRange(Positive, true);                if not SkipReservationCheck then                    UseReservationApplication := FindReservationEntryWithAdditionalCheckForAssemblyItem(ReservEntry);                IsHandled := false;                OnApplyItemLedgEntryOnBeforeCloseSurplusTrackingEntry(ItemJnlLine, StartApplication, UseReservationApplication, IsHandled);                if not IsHandled then                    if not UseReservationApplication then begin // No reservations exist                        ReservEntry.SetRange(                          "Reservation Status", ReservEntry."Reservation Status"::Tracking,                          ReservEntry."Reservation Status"::Prospect);                        if ReservEntry.FindSet() then                            repeat                                ReservEngineMgt.CloseSurplusTrackingEntry(ReservEntry);                            until ReservEntry.Next() = 0;                        StartApplication := true;                    end;                if UseReservationApplication then begin                    ReservEntry2.SetLoadFields("Source Type", "Source Ref. No.", "Item No.", "Quantity (Base)");                    OnApplyItemLedgEntryOnAfterSetLoadFieldsOnReservEntry(ReservEntry2);                    ReservEntry2.Get(ReservEntry."Entry No.", not ReservEntry.Positive);                    if ReservEntry2."Source Type" <> DATABASE::"Item Ledger Entry" then                        if ItemLedgEntry.Quantity < 0 then                            Error(Text003, ReservEntry."Item No.");                    OldItemLedgEntry.Get(ReservEntry2."Source Ref. No.");                    if ItemLedgEntry.Quantity < 0 then                        if OldItemLedgEntry."Remaining Quantity" < ReservEntry2."Quantity (Base)" then                            Error(Text003, ReservEntry2."Item No.");                    OldItemLedgEntry.TestField("Item No.", ItemJnlLine."Item No.");                    OldItemLedgEntry.TestField("Variant Code", ItemJnlLine."Variant Code");                    IsHandled := false;                    OnApplyItemLedgEntryOnBeforeTestOldItemLedgEntryLocationCode(OldItemLedgEntry, IsHandled);                    if not IsHandled then                        OldItemLedgEntry.TestField("Location Code", ItemJnlLine."Location Code");                    OnApplyItemLedgEntryOnBeforeCloseReservEntry(OldItemLedgEntry, ItemJnlLine, ItemLedgEntry, ReservEntry);                    ReservEngineMgt.CloseReservEntry(ReservEntry, false, false);                    OnApplyItemLedgEntryOnAfterCloseReservEntry(OldItemLedgEntry, ItemJnlLine, ItemLedgEntry, ReservEntry);                    OldItemLedgEntry.CalcReservedQuantity();                    AppliedQty := -Abs(ReservEntry."Quantity (Base)");                end;            end else                StartApplication := true;            OnApplyItemLedgEntryOnBeforeStartApplication(ItemLedgEntry, OldItemLedgEntry, StartApplication, AppliedQty, Item, ItemJnlLine);            if StartApplication then begin                ItemLedgEntry.CalcReservedQuantity();                if ItemLedgEntry."Applies-to Entry" <> 0 then begin                    if FirstApplication then begin                        FirstApplication := false;                        OldItemLedgEntry.Get(ItemLedgEntry."Applies-to Entry");                        TestFirstApplyItemLedgEntry(OldItemLedgEntry, ItemLedgEntry);                        OnApplyItemLedgEntryOnAfterTestFirstApplyItemLedgEntry(OldItemLedgEntry, ItemLedgEntry);                    end else                        exit;                end else                    if FindOpenItemLedgEntryToApply(ItemLedgEntry2, ItemLedgEntry, FirstApplication, EntryFindMethod) then                        OldItemLedgEntry.Copy(ItemLedgEntry2)                    else                        exit;                OldItemLedgEntry.CalcReservedQuantity();                OnAfterApplyItemLedgEntryOnBeforeCalcAppliedQty(OldItemLedgEntry, ItemLedgEntry);                if Abs(OldItemLedgEntry."Remaining Quantity" - OldItemLedgEntry."Reserved Quantity") >                   Abs(ItemLedgEntry."Remaining Quantity" - ItemLedgEntry."Reserved Quantity")                then                    AppliedQty := ItemLedgEntry."Remaining Quantity" - ItemLedgEntry."Reserved Quantity"                else begin                    AppliedQty := -(OldItemLedgEntry."Remaining Quantity" - OldItemLedgEntry."Reserved Quantity");                    if AppliedQty = 0 then                        AppliedQty := UpdateAppliedQtyIfConsumptionEntry(ItemLedgEntry, OldItemLedgEntry);                end;                OnApplyItemLedgEntryOnAfterCalcAppliedQty(OldItemLedgEntry, ItemLedgEntry, AppliedQty);                if (ItemLedgEntry."Entry Type" = ItemLedgEntry."Entry Type"::Transfer) and not ItemLedgEntry.Positive then                    if OldItemLedgEntry.EntryNoHasSameSign(ItemLedgEntry."Entry No.") and (OldItemLedgEntry."Entry No." > ItemLedgEntry."Entry No.") and (ItemLedgEntry."Entry No." >= 0) and not ItemLedgEntry.Positive or                        not OldItemLedgEntry.EntryNoHasSameSign(ItemLedgEntry."Entry No.") and ((OldItemLedgEntry.SystemId > ItemLedgEntry.SystemId) and not IsNullGuid(ItemLedgEntry.SystemId) or IsNullGuid(OldItemLedgEntry.SystemId)) // Preview?                    then                        AppliedQty := 0;                if (OldItemLedgEntry."Order Type" = OldItemLedgEntry."Order Type"::Production) and                   (OldItemLedgEntry."Order No." <> '')                then                    if not AllowProdApplication(OldItemLedgEntry, ItemLedgEntry) then                        AppliedQty := 0;                if ItemJnlLine."Applies-from Entry" <> 0 then begin                    AppliesFromItemLedgEntry.Get(ItemJnlLine."Applies-from Entry");                    if ItemApplnEntry.CheckIsCyclicalLoop(AppliesFromItemLedgEntry, OldItemLedgEntry) then                        AppliedQty := 0;                end;                OnApplyItemLedgEntryOnAfterSetAppliedQtyZero(OldItemLedgEntry, ItemLedgEntry, AppliedQty, ItemJnlLine);            end;            CheckIsCyclicalLoop(ItemLedgEntry, OldItemLedgEntry, PrevAppliedItemLedgEntry, AppliedQty);            if AppliedQty <> 0 then begin                if not OldItemLedgEntry.Positive and                   (OldItemLedgEntry."Remaining Quantity" = -AppliedQty) and                   (OldItemLedgEntry."Entry No." = ItemLedgEntry."Applies-to Entry")                then begin                    OldValueEntry.SetCurrentKey("Item Ledger Entry No.");                    OldValueEntry.SetRange("Item Ledger Entry No.", OldItemLedgEntry."Entry No.");                    if OldValueEntry.Find('-') then                        repeat                            if OldValueEntry."Valued By Average Cost" then begin                                OldValueEntry."Valued By Average Cost" := false;                                OldValueEntry.Modify();                            end;                        until OldValueEntry.Next() = 0;                end;                UpdateOldItemLedgerEntryRemainingQuantity(OldItemLedgEntry, AppliedQty);                if ItemLedgEntry.Positive then begin                    OnApplyItemLedgEntryOnItemLedgEntryPositiveOnBeforeInsertApplEntry(OldItemLedgEntry, ItemLedgEntry, GlobalItemLedgEntry, AppliedQty);                    if ItemLedgEntry."Posting Date" >= OldItemLedgEntry."Posting Date" then                        InsertApplEntry(                          OldItemLedgEntry."Entry No.", ItemLedgEntry."Entry No.",                          OldItemLedgEntry."Entry No.", 0, ItemLedgEntry."Posting Date", -AppliedQty, false)                    else                        InsertApplEntry(                          OldItemLedgEntry."Entry No.", ItemLedgEntry."Entry No.",                          OldItemLedgEntry."Entry No.", 0, OldItemLedgEntry."Posting Date", -AppliedQty, false);                    if ItemApplnEntry."Cost Application" then                        ItemLedgEntry."Applied Entry to Adjust" := true;                end else begin                    OnApplyItemLedgEntryOnBeforeCheckApplyEntry(OldItemLedgEntry);                    CheckPostingDateWithExpirationDate(ItemLedgEntry);                    OnApplyItemLedgEntryOnBeforeInsertApplEntry(ItemLedgEntry, ItemJnlLine, OldItemLedgEntry, GlobalItemLedgEntry, AppliedQty);                    InsertApplEntry(                      ItemLedgEntry."Entry No.", OldItemLedgEntry."Entry No.", ItemLedgEntry."Entry No.", 0,                      ItemLedgEntry."Posting Date", AppliedQty, true);                    if ItemApplnEntry."Cost Application" then                        OldItemLedgEntry."Applied Entry to Adjust" := true;                end;                OnApplyItemLedgEntryOnBeforeOldItemLedgEntryModify(ItemLedgEntry, OldItemLedgEntry, ItemJnlLine, AverageTransfer);                OldItemLedgEntry.Modify();                AutoTrack(OldItemLedgEntry, true);                EnsureValueEntryLoaded(ValueEntry, ItemLedgEntry);                IsHandled := false;                OnApplyItemLedgEntryOnBeforeGetValuationDate(ValueEntry, IsHandled);                if not IsHandled then                    GetValuationDate(ValueEntry, OldItemLedgEntry);                if (ItemLedgEntry."Entry Type" = ItemLedgEntry."Entry Type"::Transfer) and                   (AppliedQty < 0) and                   not CausedByTransfer and                   not ItemLedgEntry.Correction                then begin                    if ItemLedgEntry."Completely Invoiced" then                        ItemLedgEntry."Completely Invoiced" := OldItemLedgEntry."Completely Invoiced";                    if AverageTransfer then                        TotalAppliedQty := TotalAppliedQty + AppliedQty                    else                        InsertTransferEntry(ItemLedgEntry, OldItemLedgEntry, AppliedQty);                end;                OnApplyItemLedgEntryOnAfterInsertTransferEntry(ItemLedgEntry, OldItemLedgEntry, AppliedQty, CausedByTransfer);                UpdateItemLedgerEntryRemainingQuantity(ItemLedgEntry, AppliedQty, OldItemLedgEntry, CausedByTransfer);                ItemLedgEntry.CalcReservedQuantity();                IsHandled := false;                OnApplyItemLedgEntryOnBeforeZeroRemainingQtyExit(ItemLedgEntry, IsHandled);                if not IsHandled then                    if ItemLedgEntry."Remaining Quantity" + ItemLedgEntry."Reserved Quantity" = 0 then                        exit;            end;            OnApplyItemLedgEntryOnApplicationLoop(ItemLedgEntry);        until false;    end;    local procedure FindReservationEntryWithAdditionalCheckForAssemblyItem(var ReservEntry: Record "Reservation Entry"): Boolean    begin        if not ReservEntry.FindFirst() then            exit(false);        if AssemblyReservationEntryMismatchWithItemJnlLine(ReservEntry) then            exit(false);        exit(true);    end;    local procedure AssemblyReservationEntryMismatchWithItemJnlLine(var ReservEntry: Record "Reservation Entry"): Boolean    var        ReservEntry2: Record "Reservation Entry";        ItemRec: Record Item;    begin        ReservEntry2.SetLoadFields("Source Type", "Source Subtype");        ReservEntry2.Get(ReservEntry."Entry No.", not ReservEntry.Positive);        if ItemRec.Get(ReservEntry2."Item No.") then            if not (ItemRec."Assembly Policy" = ItemRec."Assembly Policy"::"Assemble-to-Stock") then                if (ReservEntry2."Source Type" = Database::"Assembly Header") and (ReservEntry2."Source Subtype" = 1)                      and (not ItemJnlLine."Assemble to Order") then                    exit(true);    end;    local procedure UpdateReservationEntryForNonInventoriableItem()    var        ReservationEntry: Record "Reservation Entry";    begin        if Item.IsInventoriableType() then            exit;        ReservationEntry.SetCurrentKey("Source ID", "Source Ref. No.", "Source Type", "Source Subtype", "Source Batch Name", "Source Prod. Order Line", "Reservation Status");        ReservationEntry.SetRange("Reservation Status", ReservationEntry."Reservation Status"::Reservation);        ItemJnlLine.SetReservationFilters(ReservationEntry);        ReservationEntry.SetRange("Item No.", ItemJnlLine."Item No.");        if not ReservationEntry.IsEmpty() then            exit;        ReservationEntry.SetRange("Reservation Status", ReservationEntry."Reservation Status"::Tracking, ReservationEntry."Reservation Status"::Prospect);        if ReservationEntry.FindSet() then            repeat                ReservEngineMgt.CloseSurplusTrackingEntry(ReservationEntry);            until ReservationEntry.Next() = 0;    end;    local procedure UpdateItemLedgerEntryRemainingQuantity(var ItemLedgerEntry: Record "Item Ledger Entry"; AppliedQty: Decimal; var OldItemLedgEntry: Record "Item Ledger Entry"; CausedByTransfer: Boolean)    begin        OnBeforeUpdateItemLedgerEntryRemainingQuantity(ItemLedgerEntry, OldItemLedgEntry, AppliedQty, CausedByTransfer, AverageTransfer);        ItemLedgerEntry."Remaining Quantity" := ItemLedgerEntry."Remaining Quantity" - AppliedQty;        ItemLedgerEntry.Open := ItemLedgerEntry."Remaining Quantity" <> 0;        OnAfterUpdateItemLedgerEntryRemainingQuantity(ItemLedgerEntry, AppliedQty);    end;    local procedure CheckPostingDateWithExpirationDate(var ItemLedgEntry: Record "Item Ledger Entry")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckPostingDateWithExpirationDate(ItemLedgEntry, GlobalItemTrackingCode, OldItemLedgEntry, IsHandled, ItemJnlLine);        if IsHandled then            exit;        if GlobalItemTrackingCode."Strict Expiration Posting" and (OldItemLedgEntry."Expiration Date" <> 0D) and           not ItemLedgEntry.Correction and           not (ItemLedgEntry."Document Type" in                [ItemLedgEntry."Document Type"::"Purchase Return Shipment", ItemLedgEntry."Document Type"::"Purchase Credit Memo"])        then            if ItemLedgEntry."Posting Date" > OldItemLedgEntry."Expiration Date" then                if (ItemLedgEntry."Entry Type" <> ItemLedgEntry."Entry Type"::"Negative Adjmt.") and                   not ItemJnlLine.IsReclass(ItemJnlLine)                then                    OldItemLedgEntry.FieldError("Expiration Date", Text017);    end;    local procedure ApplyItemLedgEntrySetFilters(var ToItemLedgEntry: Record "Item Ledger Entry"; FromItemLedgEntry: Record "Item Ledger Entry"; ItemTrackingCode: Record "Item Tracking Code")    var        Location: Record Location;        ItemTrackingSetup2: Record "Item Tracking Setup";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeApplyItemLedgEntrySetFilters(ToItemLedgEntry, FromItemLedgEntry, ItemTrackingCode, IsHandled);        if IsHandled then            exit;        ItemTrackingSetup2.CopyTrackingFromItemTrackingCodeSpecificTracking(ItemTrackingCode);        ItemTrackingSetup2.CopyTrackingFromItemLedgerEntry(FromItemLedgEntry);        if (FromItemLedgEntry."Serial No." <> '') and (ItemTrackingSetup2."Serial No. Required") then            ToItemLedgEntry.SetCurrentKey("Serial No.", "Item No.", Open, "Variant Code", Positive, "Location Code", "Posting Date", "Entry No.")        else            ToItemLedgEntry.SetCurrentKey("Item No.", Open, "Variant Code", Positive, "Location Code", "Posting Date", "Entry No.");        ToItemLedgEntry.SetRange("Item No.", FromItemLedgEntry."Item No.");        ToItemLedgEntry.SetRange(Open, true);        ToItemLedgEntry.SetRange("Variant Code", FromItemLedgEntry."Variant Code");        ToItemLedgEntry.SetRange(Positive, not FromItemLedgEntry.Positive);        ToItemLedgEntry.SetRange("Location Code", FromItemLedgEntry."Location Code");        if FromItemLedgEntry."Job Purchase" then begin            ToItemLedgEntry.SetRange("Job No.", FromItemLedgEntry."Job No.");            ToItemLedgEntry.SetRange("Job Task No.", FromItemLedgEntry."Job Task No.");            ToItemLedgEntry.SetRange("Document Type", FromItemLedgEntry."Document Type");            ToItemLedgEntry.SetRange("Document No.", FromItemLedgEntry."Document No.");        end;        ToItemLedgEntry.SetTrackingFilterFromItemTrackingSetupIfRequired(ItemTrackingSetup2);        if (Location.Get(FromItemLedgEntry."Location Code") and Location."Use As In-Transit") or           (FromItemLedgEntry."Location Code" = '') and           (FromItemLedgEntry."Document Type" = FromItemLedgEntry."Document Type"::"Transfer Receipt")        then begin            ToItemLedgEntry.SetRange("Order Type", FromItemLedgEntry."Order Type"::Transfer);            ToItemLedgEntry.SetRange("Order No.", FromItemLedgEntry."Order No.");        end;        OnAfterApplyItemLedgEntrySetFilters(ToItemLedgEntry, FromItemLedgEntry, ItemJnlLine);    end;    local procedure TestFirstApplyItemLedgEntry(var OldItemLedgEntry: Record "Item Ledger Entry"; ItemLedgEntry: Record "Item Ledger Entry")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTestFirstApplyItemLedgEntry(OldItemLedgEntry, ItemLedgEntry, ItemJnlLine, IsHandled);        if IsHandled then            exit;        OldItemLedgEntry.TestField("Item No.", ItemLedgEntry."Item No.");        OldItemLedgEntry.TestField("Variant Code", ItemLedgEntry."Variant Code");        OldItemLedgEntry.TestField(Positive, not ItemLedgEntry.Positive);        OldItemLedgEntry.TestField("Location Code", ItemLedgEntry."Location Code");        if Location.Get(ItemLedgEntry."Location Code") then            if Location."Use As In-Transit" then begin                OldItemLedgEntry.TestField("Order Type", OldItemLedgEntry."Order Type"::Transfer);                OldItemLedgEntry.TestField("Order No.", ItemLedgEntry."Order No.");            end;        TestFirstApplyItemLedgerEntryTracking(ItemLedgEntry, OldItemLedgEntry, GlobalItemTrackingCode);        IsHandled := false;        OnTestFirstApplyItemLedgEntryOnBeforeTestFields(OldItemLedgEntry, ItemLedgEntry, ItemJnlLine, IsHandled);        if not IsHandled then            if not (OldItemLedgEntry.Open and                    (Abs(OldItemLedgEntry."Remaining Quantity" - OldItemLedgEntry."Reserved Quantity") >=                     Abs(ItemLedgEntry."Remaining Quantity" - ItemLedgEntry."Reserved Quantity")))            then                if (Abs(OldItemLedgEntry."Remaining Quantity" - OldItemLedgEntry."Reserved Quantity") <=                    Abs(ItemLedgEntry."Remaining Quantity" - ItemLedgEntry."Reserved Quantity"))                then begin                    if not MoveApplication(ItemLedgEntry, OldItemLedgEntry) then                        OldItemLedgEntry.FieldError("Remaining Quantity", Text004);                end else                    OldItemLedgEntry.TestField(Open, true);        OnTestFirstApplyItemLedgEntryOnAfterTestFields(ItemLedgEntry, OldItemLedgEntry, ItemJnlLine);        OldItemLedgEntry.CalcReservedQuantity();        CheckApplication(ItemLedgEntry, OldItemLedgEntry);        IsHandled := false;        OnTestFirstApplyItemLedgEntryOnBeforeReservationPreventsApplication(OldItemLedgEntry, ItemLedgEntry, IsHandled);        if not IsHandled then            if Abs(OldItemLedgEntry."Remaining Quantity") <= Abs(OldItemLedgEntry."Reserved Quantity") then                ReservationPreventsApplication(ItemLedgEntry."Applies-to Entry", ItemLedgEntry."Item No.", OldItemLedgEntry);        if (OldItemLedgEntry."Order Type" = OldItemLedgEntry."Order Type"::Production) and           (OldItemLedgEntry."Order No." <> '')        then            if not AllowProdApplication(OldItemLedgEntry, ItemLedgEntry) then                Error(                  Text022,                  ItemLedgEntry."Entry Type", OldItemLedgEntry."Entry Type", OldItemLedgEntry."Item No.", OldItemLedgEntry."Order No.");    end;    local procedure FindOpenItemLedgEntryToApply(var OpenItemLedgEntry: Record "Item Ledger Entry"; ItemLedgEntry: Record "Item Ledger Entry"; var FirstApplication: Boolean; var EntryFindMethod: Text[1]): Boolean    begin        if FirstApplication then begin            FirstApplication := false;            ApplyItemLedgEntrySetFilters(OpenItemLedgEntry, ItemLedgEntry, GlobalItemTrackingCode);            if Item."Costing Method" = Item."Costing Method"::LIFO then                EntryFindMethod := '+'            else                EntryFindMethod := '-';            exit(OpenItemLedgEntry.Find(EntryFindMethod));        end else            case EntryFindMethod of                '-':                    exit(OpenItemLedgEntry.Next() <> 0);                '+':                    exit(OpenItemLedgEntry.Next(-1) <> 0);            end;    end;    local procedure TestFirstApplyItemLedgerEntryTracking(ItemLedgEntry: Record "Item Ledger Entry"; OldItemLedgEntry: Record "Item Ledger Entry"; ItemTrackingCode: Record "Item Tracking Code");    begin        OnBeforeTestFirstApplyItemLedgerEntryTracking(ItemLedgEntry, OldItemLedgEntry, ItemTrackingCode);        if ItemTrackingCode."SN Specific Tracking" then            OldItemLedgEntry.TestField("Serial No.", ItemLedgEntry."Serial No.");        if ItemLedgEntry."Drop Shipment" and (OldItemLedgEntry."Serial No." <> '') then            OldItemLedgEntry.TestField("Serial No.", ItemLedgEntry."Serial No.");        if ItemTrackingCode."Lot Specific Tracking" then            OldItemLedgEntry.TestField("Lot No.", ItemLedgEntry."Lot No.");        if ItemLedgEntry."Drop Shipment" and (OldItemLedgEntry."Lot No." <> '') then            OldItemLedgEntry.TestField("Lot No.", ItemLedgEntry."Lot No.");        OnAfterTestFirstApplyItemLedgerEntryTracking(ItemLedgEntry, OldItemLedgEntry, ItemTrackingCode);    end;    local procedure UpdateOldItemLedgerEntryRemainingQuantity(var OldItemLedgerEntry: Record "Item Ledger Entry"; AppliedQty: Decimal)    begin        OldItemLedgerEntry."Remaining Quantity" := OldItemLedgerEntry."Remaining Quantity" + AppliedQty;        OldItemLedgerEntry.Open := OldItemLedgerEntry."Remaining Quantity" <> 0;        OnAfterUpdateOldItemLedgerEntryRemainingQuantity(OldItemLedgerEntry, AppliedQty, GlobalItemLedgEntry, AverageTransfer);    end;    local procedure EnsureValueEntryLoaded(var ValueEntry: Record "Value Entry"; ItemLedgEntry: Record "Item Ledger Entry")    begin        ValueEntry.ReadIsolation(IsolationLevel::ReadUnCommitted);        ValueEntry.SetCurrentKey("Item Ledger Entry No.");        ValueEntry.SetRange("Item Ledger Entry No.", ItemLedgEntry."Entry No.");        if ValueEntry.FindFirst() then;    end;    local procedure AllowProdApplication(OldItemLedgEntry: Record "Item Ledger Entry"; ItemLedgEntry: Record "Item Ledger Entry"): Boolean    var        AllowApplication: Boolean;    begin        AllowApplication :=          (OldItemLedgEntry."Entry Type" = ItemLedgEntry."Entry Type") or          (OldItemLedgEntry."Order No." <> ItemLedgEntry."Order No.") or          ((OldItemLedgEntry."Order No." = ItemLedgEntry."Order No.") and           (OldItemLedgEntry."Order Line No." <> ItemLedgEntry."Order Line No."));        OnBeforeAllowProdApplication(OldItemLedgEntry, ItemLedgEntry, AllowApplication);        exit(AllowApplication);    end;    local procedure InitValueEntryNo()    begin        if ValueEntryNo <> 0 then            exit;        if not InvtSetup.UseLegacyPosting() then            exit;        GlobalValueEntry.LockTable();        ValueEntryNo := GlobalValueEntry.GetLastEntryNo();    end;    local procedure InsertTransferEntry(var ItemLedgEntry: Record "Item Ledger Entry"; var OldItemLedgEntry: Record "Item Ledger Entry"; AppliedQty: Decimal)    var        NewItemLedgEntry: Record "Item Ledger Entry";        NewValueEntry: Record "Value Entry";        ItemLedgEntry2: Record "Item Ledger Entry";        xValueEntryNo: Integer;        IsReserved: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnInsertTransferEntryOnBeforeInitNewItemLedgEntry(NewItemLedgEntry, OldItemLedgEntry, ItemLedgEntry, ItemJnlLine, AppliedQty, IsHandled);        if not IsHandled then begin            InitItemLedgEntry(NewItemLedgEntry);            NewItemLedgEntry."Applies-to Entry" := 0;            NewItemLedgEntry.Quantity := -AppliedQty;            NewItemLedgEntry."Invoiced Quantity" := NewItemLedgEntry.Quantity;            NewItemLedgEntry."Remaining Quantity" := NewItemLedgEntry.Quantity;            NewItemLedgEntry.Open := NewItemLedgEntry."Remaining Quantity" <> 0;            NewItemLedgEntry.Positive := NewItemLedgEntry."Remaining Quantity" > 0;            NewItemLedgEntry."Location Code" := ItemJnlLine."New Location Code";            NewItemLedgEntry."Country/Region Code" := ItemJnlLine."Country/Region Code";        end;        InsertCountryCode(NewItemLedgEntry, ItemLedgEntry);        NewItemLedgEntry.CopyTrackingFromNewItemJnlLine(ItemJnlLine);        NewItemLedgEntry."Expiration Date" := ItemJnlLine."New Item Expiration Date";        IsHandled := false;        OnInsertTransferEntryOnTransferValues(NewItemLedgEntry, OldItemLedgEntry, ItemLedgEntry, ItemJnlLine, TempItemEntryRelation, IsHandled);        if not IsHandled then            if Item."Item Tracking Code" <> '' then begin                TempItemEntryRelation."Item Entry No." := NewItemLedgEntry."Entry No.";                // Save Entry No. in a global variable                TempItemEntryRelation.CopyTrackingFromItemLedgEntry(NewItemLedgEntry);                OnBeforeTempItemEntryRelationInsert(TempItemEntryRelation, NewItemLedgEntry);                TempItemEntryRelation.Insert();            end;        OnInsertTransferEntryOnBeforeInitTransValueEntry(TempItemEntryRelation, NewItemLedgEntry, Item);        InitTransValueEntry(NewValueEntry, NewItemLedgEntry);        OnInsertTransferEntryOnBeforeInsertApplEntry(NewItemLedgEntry, ItemLedgEntry);        if AverageTransfer then begin            InsertApplEntry(              NewItemLedgEntry."Entry No.", NewItemLedgEntry."Entry No.", ItemLedgEntry."Entry No.",              0, NewItemLedgEntry."Posting Date", NewItemLedgEntry.Quantity, true);            NewItemLedgEntry."Completely Invoiced" := ItemLedgEntry."Completely Invoiced";        end else begin            InsertApplEntry(              NewItemLedgEntry."Entry No.", NewItemLedgEntry."Entry No.", ItemLedgEntry."Entry No.",              OldItemLedgEntry."Entry No.", NewItemLedgEntry."Posting Date", NewItemLedgEntry.Quantity, true);            NewItemLedgEntry."Completely Invoiced" := OldItemLedgEntry."Completely Invoiced";        end;        IsHandled := false;        OnInsertTransferEntryOnBeforeCalcIsReserved(ItemJnlLine, TempTrackingSpecification, NewItemLedgEntry, ItemLedgEntry, IsReserved, IsHandled);        if not IsHandled then            if NewItemLedgEntry.Quantity > 0 then                IsReserved :=                    ItemJnlLineReserve.TransferItemJnlToItemLedgEntry(                        ItemJnlLine, NewItemLedgEntry, NewItemLedgEntry."Remaining Quantity", true);        ApplyItemLedgEntry(NewItemLedgEntry, ItemLedgEntry2, NewValueEntry, true);        AutoTrack(NewItemLedgEntry, IsReserved);        OnBeforeInsertTransferEntry(NewItemLedgEntry, OldItemLedgEntry, ItemJnlLine);        InsertItemLedgEntry(NewItemLedgEntry, true);        IsHandled := false;        OnInsertTransferEntryOnBeforeInsertValueEntry(NewValueEntry, NewItemLedgEntry, ValueEntryNo, IsHandled, ItemJnlLine);        if not IsHandled then begin            InsertValueEntry(NewValueEntry, NewItemLedgEntry, true);            UpdateUnitCost(NewValueEntry);        end;        xValueEntryNo := ValueEntryNo;        OnAfterInsertTransferEntry(ItemJnlLine, NewItemLedgEntry, OldItemLedgEntry, NewValueEntry, ValueEntryNo);        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");    end;    /// <summary>    /// Initializes the item ledger entry record from the global item journal line variable.    /// </summary>    /// <param name="ItemLedgEntry">Return value: Initialized item ledger entry.</param>    procedure InitItemLedgEntry(var ItemLedgEntry: Record "Item Ledger Entry")    var        xItemLedgEntryNo: Integer;    begin        ItemLedgEntryNo := GetNextItemLedgerEntryNo(ItemLedgEntryNo);        OnInitItemLedgEntryOnBeforeInit(ItemLedgEntry, ItemJnlLine);        ItemLedgEntry.Init();        ItemLedgEntry."Entry No." := ItemLedgEntryNo;        ItemLedgEntry."Item No." := ItemJnlLine."Item No.";        ItemLedgEntry."Posting Date" := ItemJnlLine."Posting Date";        ItemLedgEntry."Document Date" := ItemJnlLine."Document Date";        ItemLedgEntry."Entry Type" := ItemJnlLine."Entry Type";        ItemLedgEntry."Source No." := ItemJnlLine."Source No.";        ItemLedgEntry."Document No." := ItemJnlLine."Document No.";        ItemLedgEntry."Document Type" := ItemJnlLine."Document Type";        ItemLedgEntry."Document Line No." := ItemJnlLine."Document Line No.";        ItemLedgEntry."Order Type" := ItemJnlLine."Order Type";        ItemLedgEntry."Order No." := ItemJnlLine."Order No.";        ItemLedgEntry."Order Line No." := ItemJnlLine."Order Line No.";        ItemLedgEntry."External Document No." := ItemJnlLine."External Document No.";        ItemLedgEntry.Description := ItemJnlLine.Description;        ItemLedgEntry."Location Code" := ItemJnlLine."Location Code";        ItemLedgEntry."Applies-to Entry" := ItemJnlLine."Applies-to Entry";        ItemLedgEntry."Source Type" := ItemJnlLine."Source Type";        ItemLedgEntry."Transaction Type" := ItemJnlLine."Transaction Type";        ItemLedgEntry."Transport Method" := ItemJnlLine."Transport Method";        ItemLedgEntry."Country/Region Code" := ItemJnlLine."Country/Region Code";        if (ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Transfer) and (ItemJnlLine."New Location Code" <> '') then begin            if NewLocation.Code <> ItemJnlLine."New Location Code" then                NewLocation.Get(ItemJnlLine."New Location Code");            ItemLedgEntry."Country/Region Code" := NewLocation."Country/Region Code";        end;        ItemLedgEntry."Entry/Exit Point" := ItemJnlLine."Entry/Exit Point";        ItemLedgEntry.Area := ItemJnlLine."Area";        ItemLedgEntry."Transaction Specification" := ItemJnlLine."Transaction Specification";        ItemLedgEntry."Drop Shipment" := ItemJnlLine."Drop Shipment";        ItemLedgEntry."Assemble to Order" := ItemJnlLine."Assemble to Order";        ItemLedgEntry."No. Series" := ItemJnlLine."Posting No. Series";        GetInvtSetup();        if (ItemLedgEntry.Description = Item.Description) and not InvtSetup."Copy Item Descr. to Entries" then            ItemLedgEntry.Description := '';        ItemLedgEntry."Variant Code" := ItemJnlLine."Variant Code";        ItemLedgEntry."Unit of Measure Code" := ItemJnlLine."Unit of Measure Code";        ItemLedgEntry."Qty. per Unit of Measure" := ItemJnlLine."Qty. per Unit of Measure";        ItemLedgEntry."Derived from Blanket Order" := ItemJnlLine."Derived from Blanket Order";        ItemLedgEntry."Item Reference No." := ItemJnlLine."Item Reference No.";        ItemLedgEntry."Originally Ordered No." := ItemJnlLine."Originally Ordered No.";        ItemLedgEntry."Originally Ordered Var. Code" := ItemJnlLine."Originally Ordered Var. Code";        ItemLedgEntry."Out-of-Stock Substitution" := ItemJnlLine."Out-of-Stock Substitution";        ItemLedgEntry."Item Category Code" := ItemJnlLine."Item Category Code";        ItemLedgEntry.Nonstock := ItemJnlLine.Nonstock;        ItemLedgEntry."Purchasing Code" := ItemJnlLine."Purchasing Code";        ItemLedgEntry."Return Reason Code" := ItemJnlLine."Return Reason Code";        ItemLedgEntry."Job No." := ItemJnlLine."Job No.";        ItemLedgEntry."Job Task No." := ItemJnlLine."Job Task No.";        ItemLedgEntry."Job Purchase" := ItemJnlLine."Job Purchase";        ItemLedgEntry.CopyTrackingFromItemJnlLine(ItemJnlLine);        ItemLedgEntry."Warranty Date" := ItemJnlLine."Warranty Date";        ItemLedgEntry."Expiration Date" := ItemJnlLine."Item Expiration Date";        ItemLedgEntry."Shpt. Method Code" := ItemJnlLine."Shpt. Method Code";        ItemLedgEntry.Correction := ItemJnlLine.Correction;        if ItemJnlLine."Entry Type" in           [ItemJnlLine."Entry Type"::Sale,            ItemJnlLine."Entry Type"::"Negative Adjmt.",            ItemJnlLine."Entry Type"::Transfer,            ItemJnlLine."Entry Type"::Consumption,            ItemJnlLine."Entry Type"::"Assembly Consumption"]        then begin            ItemLedgEntry.Quantity := -ItemJnlLine.Quantity;            ItemLedgEntry."Invoiced Quantity" := -ItemJnlLine."Invoiced Quantity";        end else begin            ItemLedgEntry.Quantity := ItemJnlLine.Quantity;            ItemLedgEntry."Invoiced Quantity" := ItemJnlLine."Invoiced Quantity";        end;        if (ItemLedgEntry.Quantity < 0) and (ItemJnlLine."Entry Type" <> ItemJnlLine."Entry Type"::Transfer) then            ItemLedgEntry."Shipped Qty. Not Returned" := ItemLedgEntry.Quantity;        xItemLedgEntryNo := ItemLedgEntryNo;        OnAfterInitItemLedgEntry(ItemLedgEntry, ItemJnlLine, ItemLedgEntryNo);        ValidateSequenceNo(ItemLedgEntryNo, xItemLedgEntryNo, Database::"Item Ledger Entry");    end;    /// <summary>    /// Creates an item ledger entry record with information from the global journal line.    /// </summary>    /// <remarks>    /// If there is insufficient quantity of the item on the inventory, an error is raised.    /// Inserts or update an item register record.    /// </remarks>    /// <param name="ItemLedgEntry">Return value: Created item ledger entry.</param>    /// <param name="TransferItem">If true, new dimension information will be set.</param>    procedure InsertItemLedgEntry(var ItemLedgEntry: Record "Item Ledger Entry"; TransferItem: Boolean)    var        xItemLedgEntryNo: Integer;        xItemApplnEntryNo: Integer;        xValueEntryNo: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertItemLedgEntryProcedure(ItemLedgEntry, IsHandled, ItemJnlLine);        if IsHandled then            exit;        if ItemLedgEntry.Open then begin            IsHandled := false;            OnInsertItemLedgEntryOnBeforeVerifyOnInventory(ItemJnlLine, ItemLedgEntry, IsHandled);            if not IsHandled then                ItemLedgEntry.VerifyOnInventory();            IsHandled := false;            OnInsertItemLedgEntryOnCheckItemTracking(ItemJnlLine, ItemLedgEntry, GlobalItemTrackingCode, IsHandled);            if not IsHandled then                if not ((ItemJnlLine."Document Type" in [ItemJnlLine."Document Type"::"Purchase Return Shipment", ItemJnlLine."Document Type"::"Purchase Receipt"]) and                        (ItemJnlLine."Job No." <> ''))                then                    if (ItemLedgEntry.Quantity < 0) and GlobalItemTrackingCode.IsSpecific() then                        Error(Text018, ItemJnlLine."Serial No.", ItemJnlLine."Lot No.", ItemJnlLine."Item No.", ItemJnlLine."Variant Code");            if GlobalItemTrackingCode."SN Specific Tracking" then begin                if ItemLedgEntry.Quantity > 0 then                    CheckItemSerialNo(ItemJnlLine);                IsHandled := false;                OnInsertItemLedgEntryOnBeforeSNQtyCheck(ItemJnlLine, IsHandled);                if not IsHandled then                    if not (ItemLedgEntry.Quantity in [-1, 0, 1]) then                        Error(Text033);            end;            if (ItemJnlLine."Document Type" <> ItemJnlLine."Document Type"::"Purchase Return Shipment") and (ItemJnlLine."Job No." = '') then                if (Item.Reserve = Item.Reserve::Always) and (ItemLedgEntry.Quantity < 0) then begin                    IsHandled := false;                    OnInsertItemLedgEntryOnBeforeReservationError(ItemJnlLine, ItemLedgEntry, IsHandled, Location);                    if not IsHandled then                        Error(Text012, ItemLedgEntry."Item No.");                end;        end;        if IsWarehouseReclassification(ItemJnlLine) then begin            ItemLedgEntry."Global Dimension 1 Code" := OldItemLedgEntry."Global Dimension 1 Code";            ItemLedgEntry."Global Dimension 2 Code" := OldItemLedgEntry."Global Dimension 2 Code";            ItemLedgEntry."Dimension Set ID" := OldItemLedgEntry."Dimension Set ID"        end else            if TransferItem then begin                ItemLedgEntry."Global Dimension 1 Code" := ItemJnlLine."New Shortcut Dimension 1 Code";                ItemLedgEntry."Global Dimension 2 Code" := ItemJnlLine."New Shortcut Dimension 2 Code";                ItemLedgEntry."Dimension Set ID" := ItemJnlLine."New Dimension Set ID";            end else begin                ItemLedgEntry."Global Dimension 1 Code" := ItemJnlLine."Shortcut Dimension 1 Code";                ItemLedgEntry."Global Dimension 2 Code" := ItemJnlLine."Shortcut Dimension 2 Code";                ItemLedgEntry."Dimension Set ID" := ItemJnlLine."Dimension Set ID";            end;        IsHandled := false;        OnInsertItemLedgEntryOnBeforeSetCompletelyInvoiced(ItemLedgEntry, ItemJnlLine, IsHandled);        if not IsHandled then begin            if not (ItemJnlLine."Entry Type" in [ItemJnlLine."Entry Type"::Transfer, ItemJnlLine."Entry Type"::Output]) and               (ItemLedgEntry.Quantity = ItemLedgEntry."Invoiced Quantity")            then                ItemLedgEntry."Completely Invoiced" := true;            if (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and (ItemJnlLine."Item Charge No." = '') and               (ItemJnlLine."Invoiced Quantity" <> 0) and (ItemJnlLine."Posting Date" > ItemLedgEntry."Last Invoice Date")            then                ItemLedgEntry."Last Invoice Date" := ItemJnlLine."Posting Date";        end;        if ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Consumption then            ItemLedgEntry."Applied Entry to Adjust" := true;        if ItemJnlLine."Job No." <> '' then begin            ItemLedgEntry."Job No." := ItemJnlLine."Job No.";            ItemLedgEntry."Job Task No." := ItemJnlLine."Job Task No.";            ItemLedgEntry."Order Line No." := ItemJnlLine."Job Contract Entry No.";        end;        ItemLedgEntry.UpdateItemTracking();        OnBeforeInsertItemLedgEntry(ItemLedgEntry, ItemJnlLine, TransferItem, OldItemLedgEntry, ItemJnlLineOrigin);        InsertItemReg(ItemLedgEntry."Entry No.", 0, 0, 0);        ItemLedgEntry."Item Register No." := ItemReg."No.";        ItemLedgEntry.Insert(true);        xItemLedgEntryNo := ItemLedgEntryNo;        xItemApplnEntryNo := ItemApplnEntryNo;        xValueEntryNo := ValueEntryNo;        OnAfterInsertItemLedgEntry(ItemLedgEntry, ItemJnlLine, ItemLedgEntryNo, ValueEntryNo, ItemApplnEntryNo, GlobalValueEntry, TransferItem, InventoryPostingToGL, OldItemLedgEntry);        ValidateSequenceNo(ItemLedgEntryNo, xItemLedgEntryNo, Database::"Item Ledger Entry");        ValidateSequenceNo(ItemApplnEntryNo, xItemApplnEntryNo, Database::"Item Application Entry");        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");    end;    local procedure InsertItemReg(ItemLedgEntryNo: Integer; PhysInvtEntryNo: Integer; ValueEntryNo: Integer; CapLedgEntryNo: Integer)    begin        if ItemReg."No." = 0 then begin            ItemReg."No." := ItemReg.GetNextEntryNo(InvtSetup.UseLegacyPosting());            ItemReg.Init();            ItemReg."From Entry No." := ItemLedgEntryNo;            ItemReg."To Entry No." := ItemLedgEntryNo;            ItemReg."From Phys. Inventory Entry No." := PhysInvtEntryNo;            ItemReg."To Phys. Inventory Entry No." := PhysInvtEntryNo;            ItemReg."From Value Entry No." := ValueEntryNo;            ItemReg."To Value Entry No." := ValueEntryNo;            ItemReg."From Capacity Entry No." := CapLedgEntryNo;            ItemReg."To Capacity Entry No." := CapLedgEntryNo;            ItemReg."Creation Date" := Today;            ItemReg."Creation Time" := Time;            ItemReg."Source Code" := ItemJnlLine."Source Code";            ItemReg."Journal Batch Name" := ItemJnlLine."Journal Batch Name";            ItemReg."User ID" := CopyStr(UserId(), 1, MaxStrLen(ItemReg."User ID"));            OnInsertItemRegOnBeforeItemRegInsert(ItemReg, ItemJnlLine);            ItemReg.Insert();        end else begin            if ((ItemLedgEntryNo < ItemReg."From Entry No.") and (ItemLedgEntryNo <> 0)) or               ((ItemReg."From Entry No." = 0) and (ItemLedgEntryNo <> 0))            then                ItemReg."From Entry No." := ItemLedgEntryNo;            if ItemLedgEntryNo > ItemReg."To Entry No." then                ItemReg."To Entry No." := ItemLedgEntryNo;            if ((PhysInvtEntryNo < ItemReg."From Phys. Inventory Entry No.") and (PhysInvtEntryNo <> 0)) or               ((ItemReg."From Phys. Inventory Entry No." = 0) and (PhysInvtEntryNo <> 0))            then                ItemReg."From Phys. Inventory Entry No." := PhysInvtEntryNo;            if PhysInvtEntryNo > ItemReg."To Phys. Inventory Entry No." then                ItemReg."To Phys. Inventory Entry No." := PhysInvtEntryNo;            if ((ValueEntryNo < ItemReg."From Value Entry No.") and (ValueEntryNo <> 0)) or               ((ItemReg."From Value Entry No." = 0) and (ValueEntryNo <> 0))            then                ItemReg."From Value Entry No." := ValueEntryNo;            if ValueEntryNo > ItemReg."To Value Entry No." then                ItemReg."To Value Entry No." := ValueEntryNo;            if ((CapLedgEntryNo < ItemReg."From Capacity Entry No.") and (CapLedgEntryNo <> 0)) or               ((ItemReg."From Capacity Entry No." = 0) and (CapLedgEntryNo <> 0))            then                ItemReg."From Capacity Entry No." := CapLedgEntryNo;            if CapLedgEntryNo > ItemReg."To Capacity Entry No." then                ItemReg."To Capacity Entry No." := CapLedgEntryNo;            ItemReg.Modify();        end;    end;    local procedure GetNextValueEntryNo(CurrValueEntryNo: Integer): Integer    begin        if InvtSetup.UseLegacyPosting() then            exit(CurrValueEntryNo + 1);        exit(GlobalValueEntry.GetNextEntryNo());    end;    local procedure GetNextItemLedgerEntryNo(CurrEntryNo: Integer): Integer    begin        if InvtSetup.UseLegacyPosting() then            exit(CurrEntryNo + 1);        exit(GlobalItemLedgEntry.GetNextEntryNo());    end;    /// <summary>    /// Inserts a physical inventory ledger entry based on a given item journal line.    /// </summary>    /// <param name="ItemJournalLine">Item journal line to insert from.</param>    procedure InsertPhysInventoryEntry(var ItemJournalLine: Record "Item Journal Line")    var        PhysInvtLedgEntry: Record "Phys. Inventory Ledger Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertPhysInventoryEntry(ItemJournalLine, IsHandled);        if IsHandled then            exit;        if InvtSetup.UseLegacyPosting() then begin            if PhysInvtEntryNo = 0 then begin                PhysInvtLedgEntry.LockTable();                PhysInvtEntryNo := PhysInvtLedgEntry.GetLastEntryNo();            end;            PhysInvtEntryNo := PhysInvtEntryNo + 1;        end else            PhysInvtEntryNo := PhysInvtLedgEntry.GetNextEntryNo();        PhysInvtLedgEntry.Init();        PhysInvtLedgEntry."Entry No." := PhysInvtEntryNo;        PhysInvtLedgEntry."Item No." := ItemJournalLine."Item No.";        PhysInvtLedgEntry."Posting Date" := ItemJournalLine."Posting Date";        PhysInvtLedgEntry."Document Date" := ItemJournalLine."Document Date";        PhysInvtLedgEntry."Entry Type" := ItemJournalLine."Entry Type";        PhysInvtLedgEntry."Document No." := ItemJournalLine."Document No.";        PhysInvtLedgEntry."External Document No." := ItemJournalLine."External Document No.";        PhysInvtLedgEntry.Description := ItemJournalLine.Description;        PhysInvtLedgEntry."Location Code" := ItemJournalLine."Location Code";        PhysInvtLedgEntry."Inventory Posting Group" := ItemJournalLine."Inventory Posting Group";        PhysInvtLedgEntry."Unit Cost" := ItemJournalLine."Unit Cost";        PhysInvtLedgEntry.Amount := ItemJournalLine.Amount;        PhysInvtLedgEntry."Salespers./Purch. Code" := ItemJournalLine."Salespers./Purch. Code";        PhysInvtLedgEntry."Source Code" := ItemJournalLine."Source Code";        PhysInvtLedgEntry."Global Dimension 1 Code" := ItemJournalLine."Shortcut Dimension 1 Code";        PhysInvtLedgEntry."Global Dimension 2 Code" := ItemJournalLine."Shortcut Dimension 2 Code";        PhysInvtLedgEntry."Dimension Set ID" := ItemJournalLine."Dimension Set ID";        PhysInvtLedgEntry."Journal Batch Name" := ItemJournalLine."Journal Batch Name";        PhysInvtLedgEntry."Reason Code" := ItemJournalLine."Reason Code";        PhysInvtLedgEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(PhysInvtLedgEntry."User ID"));        PhysInvtLedgEntry."No. Series" := ItemJournalLine."Posting No. Series";        GetInvtSetup();        if (PhysInvtLedgEntry.Description = Item.Description) and not InvtSetup."Copy Item Descr. to Entries" then            PhysInvtLedgEntry.Description := '';        PhysInvtLedgEntry."Variant Code" := ItemJournalLine."Variant Code";        PhysInvtLedgEntry."Unit of Measure Code" := ItemJournalLine."Unit of Measure Code";        PhysInvtLedgEntry.Quantity := ItemJournalLine.Quantity;        PhysInvtLedgEntry."Unit Amount" := ItemJournalLine."Unit Amount";        PhysInvtLedgEntry."Qty. (Calculated)" := ItemJournalLine."Qty. (Calculated)";        PhysInvtLedgEntry."Qty. (Phys. Inventory)" := ItemJournalLine."Qty. (Phys. Inventory)";        PhysInvtLedgEntry."Last Item Ledger Entry No." := ItemJournalLine."Last Item Ledger Entry No.";        PhysInvtLedgEntry."Phys Invt Counting Period Code" :=          ItemJournalLine."Phys Invt Counting Period Code";        PhysInvtLedgEntry."Phys Invt Counting Period Type" :=          ItemJournalLine."Phys Invt Counting Period Type";        OnBeforeInsertPhysInvtLedgEntry(PhysInvtLedgEntry, ItemJournalLine, ItemJnlLine);        InsertItemReg(0, PhysInvtLedgEntry."Entry No.", 0, 0);        PhysInvtLedgEntry."Item Register No." := ItemReg."No.";        PhysInvtLedgEntry.Insert(true);        OnAfterInsertPhysInventoryEntry(PhysInvtLedgEntry, ItemJnlLineOrigin);    end;    /// <summary>    /// Posts inventory transactions to the general ledger based on the provided value entry.    /// </summary>    /// <param name="ValueEntry">Value entry to post from.</param>    procedure PostInventoryToGL(var ValueEntry: Record "Value Entry")    var        IsHandled: Boolean;    begin        if Item."No." <> ValueEntry."Item No." then            Item.Get(ValueEntry."Item No.");        IsHandled := false;        OnBeforePostInventoryToGL(ValueEntry, IsHandled, ItemJnlLine, PostToGL, CalledFromAdjustment, Item."Inventory Value Zero");        if IsHandled then            exit;        if not ValueEntry.Inventoriable or           not CalledFromAdjustment and Item."Inventory Value Zero" or           CalledFromAdjustment and not PostToGL        then            exit;        IsHandled := false;        OnBeforePostValueEntryToGL(ValueEntry, IsHandled, PostToGL);        if IsHandled then            exit;        PostValueEntryToGL(ValueEntry);    end;    /// <summary>    /// Posts inventory transactions to the general ledger based on the provided value entry.    /// </summary>    /// <param name="ValueEntry">Value entry to post from.</param>    internal procedure PostValueEntryToGL(var ValueEntry: Record "Value Entry")    begin        InventoryPostingToGL.SetRunOnlyCheck(true, not PostToGL, false);        OnPostInventoryToGLOnBeforePostInvtBuffer(InventoryPostingToGL, PostToGL);        PostInvtBuffer(ValueEntry);        OnPostInventoryToGLOnAfterPostInvtBuffer(ValueEntry);        if ValueEntry."Expected Cost" then begin            if (ValueEntry."Cost Amount (Expected)" = 0) and (ValueEntry."Cost Amount (Expected) (ACY)" = 0) then                SetValueEntry(ValueEntry, 1, 1, false)            else                SetValueEntry(ValueEntry, ValueEntry."Cost Amount (Expected)", ValueEntry."Cost Amount (Expected) (ACY)", false);            InventoryPostingToGL.SetRunOnlyCheck(true, true, false);            PostInvtBuffer(ValueEntry);            SetValueEntry(ValueEntry, 0, 0, true);        end else            if (ValueEntry."Cost Amount (Actual)" = 0) and (ValueEntry."Cost Amount (Actual) (ACY)" = 0) then begin                SetValueEntry(ValueEntry, 1, 1, false);                InventoryPostingToGL.SetRunOnlyCheck(true, true, false);                PostInvtBuffer(ValueEntry);                SetValueEntry(ValueEntry, 0, 0, false);            end;        OnAfterPostInventoryToGL(ValueEntry);    end;    local procedure SetValueEntry(var ValueEntry: Record "Value Entry"; CostAmtActual: Decimal; CostAmtActACY: Decimal; ExpectedCost: Boolean)    begin        ValueEntry."Cost Amount (Actual)" := CostAmtActual;        ValueEntry."Cost Amount (Actual) (ACY)" := CostAmtActACY;        ValueEntry."Expected Cost" := ExpectedCost;    end;    /// <summary>    /// Creates an item application entry.    /// </summary>    /// <remarks>    /// If the item is non-inventoriable, procedure is not executed.    /// </remarks>    /// <param name="ItemLedgEntryNo">Item ledger entry no.</param>    /// <param name="InboundItemEntry">Inbound item ledger entry no.</param>    /// <param name="OutboundItemEntry">Outbound item ledger entry no.</param>    /// <param name="TransferedFromEntryNo">Transferred-from entry no.</param>    /// <param name="PostingDate">Item ledger entry posting date.</param>    /// <param name="Quantity">Item ledger entry quantity.</param>    /// <param name="CostToApply">If true, then cost application will be set to true.</param>    procedure InsertApplEntry(ItemLedgEntryNo: Integer; InboundItemEntry: Integer; OutboundItemEntry: Integer; TransferedFromEntryNo: Integer; PostingDate: Date; Quantity: Decimal; CostToApply: Boolean)    var        ApplItemLedgEntry: Record "Item Ledger Entry";        OldItemApplnEntry: Record "Item Application Entry";        ItemApplHistoryEntry: Record "Item Application Entry History";        ItemApplnEntryExists: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertApplEntry(            ItemLedgEntryNo, InboundItemEntry, OutboundItemEntry, TransferedFromEntryNo, PostingDate, Quantity, CostToApply, IsHandled);        if IsHandled then            exit;        if Item.IsNonInventoriableType() then            exit;        if (ItemApplnEntryNo = 0) and InvtSetup.UseLegacyPosting() then begin            ItemApplnEntry.Reset();            ItemApplnEntry.LockTable();            ItemApplnEntryNo := ItemApplnEntry.GetLastEntryNo();            if ItemApplnEntryNo > 0 then begin                ItemApplHistoryEntry.Reset();                ItemApplHistoryEntry.LockTable();                ItemApplHistoryEntry.SetCurrentKey("Entry No.");                if ItemApplHistoryEntry.FindLast() then                    if ItemApplHistoryEntry."Entry No." > ItemApplnEntryNo then                        ItemApplnEntryNo := ItemApplHistoryEntry."Entry No.";            end else                ItemApplnEntryNo := 0;        end;        if Quantity < 0 then begin            OldItemApplnEntry.SetCurrentKey("Inbound Item Entry No.", "Item Ledger Entry No.", "Outbound Item Entry No.");            OldItemApplnEntry.SetRange("Inbound Item Entry No.", InboundItemEntry);            OldItemApplnEntry.SetRange("Item Ledger Entry No.", ItemLedgEntryNo);            OldItemApplnEntry.SetRange("Outbound Item Entry No.", OutboundItemEntry);            if OldItemApplnEntry.FindFirst() then begin                ItemApplnEntry := OldItemApplnEntry;                ItemApplnEntry.Quantity := ItemApplnEntry.Quantity + Quantity;                ItemApplnEntry."Last Modified Date" := CurrentDateTime;                ItemApplnEntry."Last Modified By User" := UserId;                OnInsertApplEntryOnBeforeModify(ItemApplnEntry);                ItemApplnEntry.Modify();                ItemApplnEntryExists := true;            end;        end;        if not ItemApplnEntryExists then begin            if InvtSetup.UseLegacyPosting() then                ItemApplnEntryNo := ItemApplnEntryNo + 1            else                ItemApplnEntryNo := ItemApplnEntry.GetNextEntryNo();            ItemApplnEntry.Init();            ItemApplnEntry."Entry No." := ItemApplnEntryNo;            ItemApplnEntry."Item Ledger Entry No." := ItemLedgEntryNo;            ItemApplnEntry."Inbound Item Entry No." := InboundItemEntry;            ItemApplnEntry."Outbound Item Entry No." := OutboundItemEntry;            ItemApplnEntry."Transferred-from Entry No." := TransferedFromEntryNo;            ItemApplnEntry.Quantity := Quantity;            ItemApplnEntry."Posting Date" := PostingDate;            ItemApplnEntry."Output Completely Invd. Date" := GetOutputComplInvcdDate(ItemApplnEntry);            if AverageTransfer then begin                if (Quantity > 0) or (ItemJnlLine."Document Type" = ItemJnlLine."Document Type"::"Transfer Receipt") then                    ItemApplnEntry."Cost Application" :=                      ItemApplnEntry.IsOutbndItemApplEntryCostApplication(ItemLedgEntryNo) and IsNotValuedByAverageCost(ItemLedgEntryNo);            end else                case true of                    Item."Costing Method" <> Item."Costing Method"::Average,                  ItemJnlLine.Correction and (ItemJnlLine."Document Type" = ItemJnlLine."Document Type"::"Posted Assembly"):                        ItemApplnEntry."Cost Application" := true;                    ItemJnlLine.Correction:                        begin                            if (ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Output) and (ItemJnlLine."Order Type" = ItemJnlLine."Order Type"::Production) and ItemJnlLine.Subcontracting then                                ApplItemLedgEntry := GlobalItemLedgEntry                            else                                ApplItemLedgEntry.Get(ItemApplnEntry."Item Ledger Entry No.");                            ItemApplnEntry."Cost Application" :=                              (ApplItemLedgEntry.Quantity > 0) or (ApplItemLedgEntry."Applies-to Entry" <> 0);                        end;                    else                        if (ItemJnlLine."Applies-to Entry" <> 0) or                           (CostToApply and ItemJnlLine.IsInbound())                        then                            ItemApplnEntry."Cost Application" := true;                end;            ItemApplnEntry."Creation Date" := CurrentDateTime;            ItemApplnEntry."Created By User" := UserId;            OnBeforeItemApplnEntryInsert(ItemApplnEntry, GlobalItemLedgEntry, OldItemLedgEntry, ItemApplnEntryNo);            ItemApplnEntry.Insert(true);            OnAfterItemApplnEntryInsert(ItemApplnEntry, GlobalItemLedgEntry, OldItemLedgEntry);        end;    end;    local procedure UpdateItemApplnEntry(ItemLedgEntryNo: Integer; PostingDate: Date)    var        ItemApplnEntry: Record "Item Application Entry";    begin        ItemApplnEntry.SetRange("Item Ledger Entry No.", ItemLedgEntryNo);        ItemApplnEntry.SetRange("Output Completely Invd. Date", 0D);        OnUpdateItemApplnEntryOnAfterFilterItemApplicationEntry(ItemApplnEntry);        if not ItemApplnEntry.IsEmpty() then            ItemApplnEntry.ModifyAll("Output Completely Invd. Date", PostingDate);    end;    local procedure GetOutputComplInvcdDate(ItemApplnEntry: Record "Item Application Entry"): Date    var        OutbndItemLedgEntry: Record "Item Ledger Entry";    begin        OnBeforeGetOutputComplInvcdDate(ItemApplnEntry);        if ItemApplnEntry.Quantity > 0 then            exit(ItemApplnEntry."Posting Date");        if OutbndItemLedgEntry.Get(ItemApplnEntry."Outbound Item Entry No.") then            if OutbndItemLedgEntry."Completely Invoiced" then                exit(OutbndItemLedgEntry."Last Invoice Date");    end;    local procedure InitValueEntry(var ValueEntry: Record "Value Entry"; ItemLedgerEntry: Record "Item Ledger Entry")    var        InvoicedQuantityNotEmpty: Boolean;        CostAmt: Decimal;        CostAmtACY: Decimal;        xValueEntryNo: Integer;    begin        xValueEntryNo := ValueEntryNo;        OnBeforeInitValueEntry(ValueEntry, ValueEntryNo, ItemJnlLine);        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");        ValueEntryNo := GetNextValueEntryNo(ValueEntryNo);        ValueEntry.Init();        ValueEntry."Entry No." := ValueEntryNo;        if ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::Variance then            ValueEntry."Variance Type" := ItemJnlLine."Variance Type";        ValueEntry."Item Ledger Entry No." := ItemLedgerEntry."Entry No.";        ValueEntry."Item No." := ItemJnlLine."Item No.";        ValueEntry."Item Charge No." := ItemJnlLine."Item Charge No.";        ValueEntry."Order Type" := ItemLedgerEntry."Order Type";        ValueEntry."Order No." := ItemLedgerEntry."Order No.";        ValueEntry."Order Line No." := ItemLedgerEntry."Order Line No.";        ValueEntry."Item Ledger Entry Type" := ItemJnlLine."Entry Type";        ValueEntry.Type := ItemJnlLine.Type;        ValueEntry."Posting Date" := ItemJnlLine."Posting Date";        ValueEntry."VAT Reporting Date" := ItemJnlLine."VAT Reporting Date";        if ItemJnlLine."Partial Revaluation" then            ValueEntry."Partial Revaluation" := true;        OnInitValueEntryOnAfterAssignFields(ValueEntry, ItemLedgerEntry, ItemJnlLine);        if (ItemLedgerEntry.Quantity > 0) or            (ItemLedgerEntry."Invoiced Quantity" > 0) or            ((ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and (ItemJnlLine."Item Charge No." = '')) or            (ItemJnlLine."Entry Type" in [ItemJnlLine."Entry Type"::Output, ItemJnlLine."Entry Type"::"Assembly Output"]) or            ItemJnlLine.Adjustment        then            ValueEntry.Inventoriable := Item.Type = Item.Type::Inventory;        OnInitValueEntryOnAfterSetValueEntryInventoriable(ValueEntry, ItemJnlLine);        if ((ItemJnlLine.Quantity = 0) and (ItemJnlLine."Invoiced Quantity" <> 0)) or            (ItemJnlLine."Value Entry Type" <> ItemJnlLine."Value Entry Type"::"Direct Cost") or            (ItemJnlLine."Item Charge No." <> '') or ItemJnlLine.Adjustment        then begin            GetLastDirectCostValEntry(ValueEntry."Item Ledger Entry No.");            if ValueEntry.Inventoriable and (ItemJnlLine."Item Charge No." = '') then                ValueEntry."Valued By Average Cost" := DirCostValueEntry."Valued By Average Cost";        end;        case true of            ((ItemJnlLine.Quantity = 0) and (ItemJnlLine."Invoiced Quantity" <> 0)) or            ((ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and (ItemJnlLine."Item Charge No." <> '')) or            ItemJnlLine.Adjustment or (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::Rounding):                ValueEntry."Valuation Date" := DirCostValueEntry."Valuation Date";            (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::Revaluation):                if ItemJnlLine."Posting Date" < DirCostValueEntry."Valuation Date" then                    ValueEntry."Valuation Date" := DirCostValueEntry."Valuation Date"                else                    ValueEntry."Valuation Date" := ItemJnlLine."Posting Date";            (ItemLedgerEntry.Quantity > 0) and (ItemJnlLine."Applies-from Entry" <> 0):                GetAppliedFromValues(ValueEntry);            else                ValueEntry."Valuation Date" := ItemJnlLine."Posting Date";        end;        RedirectInvoicingValuationDateToPostingDate(ValueEntry);        CheckValuationDateAllowed(ValueEntry);        GetInvtSetup();        if (ItemJnlLine.Description = Item.Description) and not InvtSetup."Copy Item Descr. to Entries" then            ValueEntry.Description := ''        else            ValueEntry.Description := ItemJnlLine.Description;        SetValueEntrySourceFieldsFromItemJnlLine(ValueEntry, ItemJnlLine);        if (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and (ItemJnlLine."Item Charge No." = '') then            ValueEntry."Inventory Posting Group" := ItemJnlLine."Inventory Posting Group"        else            ValueEntry."Inventory Posting Group" := DirCostValueEntry."Inventory Posting Group";        ValueEntry."Source Posting Group" := ItemJnlLine."Source Posting Group";        ValueEntry."Salespers./Purch. Code" := ItemJnlLine."Salespers./Purch. Code";        ValueEntry."Location Code" := ItemLedgerEntry."Location Code";        ValueEntry."Variant Code" := ItemLedgerEntry."Variant Code";        ValueEntry."Journal Batch Name" := ItemJnlLine."Journal Batch Name";        ValueEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(ValueEntry."User ID"));        ValueEntry."Drop Shipment" := ItemJnlLine."Drop Shipment";        ValueEntry."Reason Code" := ItemJnlLine."Reason Code";        ValueEntry."Return Reason Code" := ItemJnlLine."Return Reason Code";        ValueEntry."External Document No." := ItemJnlLine."External Document No.";        ValueEntry."Document Date" := ItemJnlLine."Document Date";        ValueEntry."Gen. Bus. Posting Group" := ItemJnlLine."Gen. Bus. Posting Group";        ValueEntry."Gen. Prod. Posting Group" := ItemJnlLine."Gen. Prod. Posting Group";        ValueEntry."Discount Amount" := ItemJnlLine."Discount Amount";        ValueEntry."Entry Type" := ItemJnlLine."Value Entry Type";        if ItemJnlLine."Job No." <> '' then begin            ValueEntry."Job No." := ItemJnlLine."Job No.";            ValueEntry."Job Task No." := ItemJnlLine."Job Task No.";        end;        InvoicedQuantityNotEmpty := ItemJnlLine."Invoiced Quantity" <> 0;        OnInitValueEntryOnAfterCalcInvoicedQuantityNotEmpty(ItemJnlLine, InvoicedQuantityNotEmpty);        if InvoicedQuantityNotEmpty then begin            ValueEntry."Valued Quantity" := ItemJnlLine."Invoiced Quantity";            if (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and                (ItemJnlLine."Item Charge No." = '')            then                if (ItemJnlLine."Entry Type" <> ItemJnlLine."Entry Type"::Output) or                    (ItemLedgerEntry."Invoiced Quantity" = 0)                then                    ValueEntry."Invoiced Quantity" := ItemJnlLine."Invoiced Quantity";            ValueEntry."Expected Cost" := false;        end else begin            ValueEntry."Valued Quantity" := ItemJnlLine.Quantity;            ValueEntry."Expected Cost" := ItemJnlLine."Value Entry Type" <> ItemJnlLine."Value Entry Type"::Revaluation;        end;        ValueEntry."Document Type" := ItemJnlLine."Document Type";        if ValueEntry."Expected Cost" or (ItemJnlLine."Invoice No." = '') then            ValueEntry."Document No." := ItemJnlLine."Document No."        else begin            ValueEntry."Document No." := ItemJnlLine."Invoice No.";            if ItemJnlLine."Document Type" in [                                    ItemJnlLine."Document Type"::"Purchase Receipt", ItemJnlLine."Document Type"::"Purchase Return Shipment",                                    ItemJnlLine."Document Type"::"Sales Shipment", ItemJnlLine."Document Type"::"Sales Return Receipt",                                    ItemJnlLine."Document Type"::"Service Shipment"]            then                ValueEntry."Document Type" := Enum::"Item Ledger Document Type".FromInteger(ItemJnlLine."Document Type".AsInteger() + 1);        end;        OnInitValueEntryOnBeforeSetDocumentLineNo(ItemJnlLine, ItemLedgerEntry, ValueEntry);        ValueEntry."Document Line No." := ItemJnlLine."Document Line No.";        if ItemJnlLine.Adjustment then begin            ValueEntry."Invoiced Quantity" := 0;            ValueEntry."Applies-to Entry" := ItemJnlLine."Applies-to Value Entry";            ValueEntry.Adjustment := true;        end;        if ItemJnlLine."Value Entry Type" <> ItemJnlLine."Value Entry Type"::Rounding then begin            if (ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Output) and                (ItemJnlLine."Value Entry Type" <> ItemJnlLine."Value Entry Type"::Revaluation)            then begin                CostAmt := ItemJnlLine.Amount;                CostAmtACY := ItemJnlLine."Amount (ACY)";            end else begin                ValueEntry."Cost per Unit" := RetrieveCostPerUnit(ItemJnlLine, SKU, SKUExists);                if GLSetup."Additional Reporting Currency" <> '' then                    ValueEntry."Cost per Unit (ACY)" := RetrieveCostPerUnitACY(ValueEntry."Cost per Unit");                CalcCostPerUnitForPositiveValuedQty(ItemJnlLine, ValueEntry, CostAmt, CostAmtACY);                if (ItemJnlLine."Invoiced Quantity" < 0) and (ItemJnlLine."Applies-to Entry" <> 0) and                    (ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Purchase) and (ItemJnlLine."Item Charge No." = '') and                    (ValueEntry."Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost")                then begin                    CalcPurchCorrShares(OverheadAmount, OverheadAmountACY, VarianceAmount, VarianceAmountACY);                    SetCostAmountAndCostAmountFCYOnSameCostPerUnit(ItemJnlLine, CostAmt, CostAmtACY);                    OnAfterCalcPurchCorrShares(                        ValueEntry, ItemJnlLine, OverheadAmount, OverheadAmountACY, VarianceAmount, VarianceAmountACY);                end;            end;            OnInitValueEntryOnAfterCalcDirestCost(CostAmt, VarianceAmount, Item, ItemJnlLine, ValueEntry, CostAmtACY, VarianceAmountACY);        end else begin            CostAmt := ItemJnlLine."Unit Cost";            CostAmtACY := ItemJnlLine."Unit Cost (ACY)";        end;        if (ValueEntry."Entry Type" <> ValueEntry."Entry Type"::Revaluation) and not ItemJnlLine.Adjustment then            if (ValueEntry."Item Ledger Entry Type" in                [ValueEntry."Item Ledger Entry Type"::Sale,                    ValueEntry."Item Ledger Entry Type"::"Negative Adjmt.",                    ValueEntry."Item Ledger Entry Type"::Consumption,                    ValueEntry."Item Ledger Entry Type"::"Assembly Consumption"]) or                ((ValueEntry."Item Ledger Entry Type" = ValueEntry."Item Ledger Entry Type"::Transfer) and                (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and (ItemJnlLine."Item Charge No." = ''))            then begin                ValueEntry."Valued Quantity" := -ValueEntry."Valued Quantity";                ValueEntry."Invoiced Quantity" := -ValueEntry."Invoiced Quantity";                if ValueEntry."Item Ledger Entry Type" = ValueEntry."Item Ledger Entry Type"::Transfer then                    ValueEntry."Discount Amount" := 0                else                    ValueEntry."Discount Amount" := -ValueEntry."Discount Amount";                if ItemJnlLine."Value Entry Type" <> ItemJnlLine."Value Entry Type"::Rounding then begin                    CostAmt := -CostAmt;                    CostAmtACY := -CostAmtACY;                end;            end;        if not ItemJnlLine.Adjustment then            if Item."Inventory Value Zero" or                ((ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Transfer) and                (ValueEntry."Valued Quantity" < 0) and not AverageTransfer) or                ((ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Sale) and                (ItemJnlLine."Item Charge No." <> ''))            then begin                CostAmt := 0;                CostAmtACY := 0;                ValueEntry."Cost per Unit" := 0;                ValueEntry."Cost per Unit (ACY)" := 0;                OnInitValueEntryOnAfterNotAdjustmentCheckClearCostAmount(ValueEntry, ItemJnlLine);            end;        case true of            (not ValueEntry."Expected Cost") and ValueEntry.Inventoriable and            IsInterimRevaluation():                begin                    ValueEntry."Cost Amount (Expected)" := Round(CostAmt * ItemJnlLine."Applied Amount" / ItemJnlLine.Amount);                    ValueEntry."Cost Amount (Expected) (ACY)" := Round(CostAmtACY * ItemJnlLine."Applied Amount" / ItemJnlLine.Amount,                        Currency."Amount Rounding Precision");                    CostAmt := Round(CostAmt);                    CostAmtACY := Round(CostAmtACY, Currency."Amount Rounding Precision");                    ValueEntry."Cost Amount (Actual)" := CostAmt - ValueEntry."Cost Amount (Expected)";                    ValueEntry."Cost Amount (Actual) (ACY)" := CostAmtACY - ValueEntry."Cost Amount (Expected) (ACY)";                end;            (not ValueEntry."Expected Cost") and ValueEntry.Inventoriable:                begin                    if not ItemJnlLine.Adjustment and (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") then                        case ItemJnlLine."Entry Type" of                            ItemJnlLine."Entry Type"::Sale:                                ValueEntry."Sales Amount (Actual)" := ItemJnlLine.Amount;                            ItemJnlLine."Entry Type"::Purchase:                                ValueEntry."Purchase Amount (Actual)" := ItemJnlLine.Amount;                        end;                    ValueEntry."Cost Amount (Actual)" := CostAmt;                    ValueEntry."Cost Amount (Actual) (ACY)" := CostAmtACY;                end;            ValueEntry."Expected Cost" and ValueEntry.Inventoriable:                begin                    if not ItemJnlLine.Adjustment then                        case ItemJnlLine."Entry Type" of                            ItemJnlLine."Entry Type"::Sale:                                ValueEntry."Sales Amount (Expected)" := ItemJnlLine.Amount;                            ItemJnlLine."Entry Type"::Purchase:                                ValueEntry."Purchase Amount (Expected)" := ItemJnlLine.Amount;                        end;                    ValueEntry."Cost Amount (Expected)" := CostAmt;                    ValueEntry."Cost Amount (Expected) (ACY)" := CostAmtACY;                end;            (not ValueEntry."Expected Cost") and (not ValueEntry.Inventoriable):                if ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Sale then begin                    ValueEntry."Sales Amount (Actual)" := ItemJnlLine.Amount;                    if Item.IsNonInventoriableType() then begin                        ValueEntry."Cost Amount (Non-Invtbl.)" := CostAmt;                        ValueEntry."Cost Amount (Non-Invtbl.)(ACY)" := CostAmtACY;                    end else begin                        ValueEntry."Cost per Unit" := 0;                        ValueEntry."Cost per Unit (ACY)" := 0;                    end;                end else begin                    if ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Purchase then                        ValueEntry."Purchase Amount (Actual)" := ItemJnlLine.Amount;                    ValueEntry."Cost Amount (Non-Invtbl.)" := CostAmt;                    ValueEntry."Cost Amount (Non-Invtbl.)(ACY)" := CostAmtACY;                end;        end;        OnInitValueEntryOnBeforeRoundAmtValueEntry(ValueEntry, ItemJnlLine);        RoundAmtValueEntry(ValueEntry);        xValueEntryNo := ValueEntryNo;        OnAfterInitValueEntry(ValueEntry, ItemJnlLine, ValueEntryNo, ItemLedgerEntry);        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");    end;    local procedure CalcCostPerUnitForPositiveValuedQty(var ItemJournalLine: Record "Item Journal Line"; var ValueEntry: Record "Value Entry"; var CostAmt: Decimal; var CostAmtACY: Decimal)    var        CalcUnitCost: Boolean;        IsHandled: Boolean;        ShouldCalculateCostPerUnit: Boolean;    begin        OnBeforeCalcCostPerUnitForPositiveValuedQty(ItemJournalLine, ValueEntry, IsHandled);        if IsHandled then            exit;        ShouldCalculateCostPerUnit :=            (ValueEntry."Valued Quantity" > 0) and            (ValueEntry."Item Ledger Entry Type" in [ValueEntry."Item Ledger Entry Type"::Purchase,                                                    ValueEntry."Item Ledger Entry Type"::"Assembly Output"]) and            (ValueEntry."Entry Type" = ValueEntry."Entry Type"::"Direct Cost") and            not ItemJnlLine.Adjustment;        OnCalcCostPerUnitForPositiveValuedQtyOnBeforeCheckShouldCalculateCostPerUnit(ValueEntry, ItemJournalLine, ShouldCalculateCostPerUnit);        if ShouldCalculateCostPerUnit then begin            if Item."Costing Method" = Item."Costing Method"::Standard then                ItemJnlLine."Unit Cost" := ValueEntry."Cost per Unit";            CalcPosShares(                CostAmt, OverheadAmount, VarianceAmount, CostAmtACY, OverheadAmountACY, VarianceAmountACY,                CalcUnitCost, (Item."Costing Method" = Item."Costing Method"::Standard) and                (not ValueEntry."Expected Cost"), ValueEntry."Expected Cost");            if (OverheadAmount <> 0) or                (Round(VarianceAmount, GLSetup."Amount Rounding Precision") <> 0) or                CalcUnitCost or ValueEntry."Expected Cost"            then begin                ValueEntry."Cost per Unit" :=                    CalcCostPerUnit(CostAmt, ValueEntry."Valued Quantity", false);                if GLSetup."Additional Reporting Currency" <> '' then                    ValueEntry."Cost per Unit (ACY)" :=                        CalcCostPerUnit(CostAmtACY, ValueEntry."Valued Quantity", true);            end;        end else            if not ItemJnlLine.Adjustment then                CalcOutboundCostAmt(ValueEntry, CostAmt, CostAmtACY)            else begin                CostAmt := ItemJnlLine.Amount;                CostAmtACY := ItemJnlLine."Amount (ACY)";            end;    end;    local procedure SetValueEntrySourceFieldsFromItemJnlLine(var ValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line")    begin        OnBeforeSetValueEntrySourceFieldsFromItemJnlLine(ValueEntry, ItemJournalLine);        ValueEntry."Source Code" := ItemJournalLine."Source Code";        ValueEntry."Source Type" := ItemJournalLine."Source Type";        ValueEntry."Source No." := GetSourceNo(ItemJournalLine);    end;    local procedure CalcOutboundCostAmt(ValueEntry: Record "Value Entry"; var CostAmt: Decimal; var CostAmtACY: Decimal)    begin        if ItemJnlLine."Item Charge No." <> '' then begin            CostAmt := ItemJnlLine.Amount;            if GLSetup."Additional Reporting Currency" <> '' then                CostAmtACY := ACYMgt.CalcACYAmt(CostAmt, ValueEntry."Posting Date", false);        end else begin            if IsNondeductibleAndUseItemCost() then begin                CostAmt := ItemJnlLine.Amount;                CostAmtACY := ACYMgt.CalcACYAmt(CostAmt, ValueEntry."Posting Date", false);            end            else begin                CostAmt :=                  ValueEntry."Cost per Unit" * ValueEntry."Valued Quantity";                CostAmtACY :=                  ValueEntry."Cost per Unit (ACY)" * ValueEntry."Valued Quantity";            end;            if MustConsiderUnitCostRoundingOnRevaluation(ItemJnlLine) then begin                CostAmt += RoundingResidualAmount;                CostAmtACY += RoundingResidualAmountACY;            end;        end;    end;    /// <summary>    /// Inserts the value entry for an item ledger entry and posts it to the general ledger.    /// </summary>    /// <remarks>    /// Updates item ledger entry based on a value entry.    /// Posts value entry information to the general ledger.    /// Inserts or updates item register record based on a value entry.    /// </remarks>    /// <param name="ValueEntry">Return value: Inserted value entry record.</param>    /// <param name="ItemLedgEntry">Return value: Item ledger entry to insert value entry for.</param>    /// <param name="TransferItem">    /// If true, global dimension codes and dimension set ID will be changed to new shorcut dimension values     /// instead of shortcut dimension values. A new shortcut dimension on an item journal line refers to adding a     /// new dimension specifically for item-related entries, providing additional flexibility and analysis capabilities     /// within the context of item transactions.    /// </param>    procedure InsertValueEntry(var ValueEntry: Record "Value Entry"; var ItemLedgEntry: Record "Item Ledger Entry"; TransferItem: Boolean)    var        InvdValueEntry: Record "Value Entry";        InvoicedQty: Decimal;        IsHandled: Boolean;        xValueEntryNo: Integer;        ShouldCalcExpectedCost: Boolean;    begin        OnBeforeInsertValueEntryProcedure(ItemLedgEntry, ItemJnlLine);        if IsWarehouseReclassification(ItemJnlLine) then begin            ValueEntry."Dimension Set ID" := OldItemLedgEntry."Dimension Set ID";            ValueEntry."Global Dimension 1 Code" := OldItemLedgEntry."Global Dimension 1 Code";            ValueEntry."Global Dimension 2 Code" := OldItemLedgEntry."Global Dimension 2 Code";        end else            if TransferItem then begin                ValueEntry."Global Dimension 1 Code" := ItemJnlLine."New Shortcut Dimension 1 Code";                ValueEntry."Global Dimension 2 Code" := ItemJnlLine."New Shortcut Dimension 2 Code";                ValueEntry."Dimension Set ID" := ItemJnlLine."New Dimension Set ID";            end else                if (GlobalValueEntry."Entry Type" = GlobalValueEntry."Entry Type"::"Direct Cost") and                   (GlobalValueEntry."Item Charge No." <> '') and                   (ValueEntry."Entry Type" = ValueEntry."Entry Type"::Variance)                then begin                    GetLastDirectCostValEntry(ValueEntry."Item Ledger Entry No.");                    ValueEntry."Gen. Prod. Posting Group" := DirCostValueEntry."Gen. Prod. Posting Group";                    MoveValEntryDimToValEntryDim(ValueEntry, DirCostValueEntry);                end else begin                    ValueEntry."Global Dimension 1 Code" := ItemJnlLine."Shortcut Dimension 1 Code";                    ValueEntry."Global Dimension 2 Code" := ItemJnlLine."Shortcut Dimension 2 Code";                    ValueEntry."Dimension Set ID" := ItemJnlLine."Dimension Set ID";                end;        OnInsertValueEntryOnBeforeRoundAmtValueEntry(ValueEntry, ItemLedgEntry, ItemJnlLine, TransferItem);        RoundAmtValueEntry(ValueEntry);        if ValueEntry."Entry Type" = ValueEntry."Entry Type"::Rounding then begin            ValueEntry."Valued Quantity" := ItemLedgEntry.Quantity;            ValueEntry."Invoiced Quantity" := 0;            ValueEntry."Cost per Unit" := 0;            ValueEntry."Sales Amount (Actual)" := 0;            ValueEntry."Purchase Amount (Actual)" := 0;            ValueEntry."Cost per Unit (ACY)" := 0;            ValueEntry."Item Ledger Entry Quantity" := 0;        end else begin            if IsFirstValueEntry(ValueEntry."Item Ledger Entry No.") then                ValueEntry."Item Ledger Entry Quantity" := ValueEntry."Valued Quantity"            else                ValueEntry."Item Ledger Entry Quantity" := 0;            RecalculateCostPerUnit(ValueEntry, ItemLedgEntry);            if UpdateItemLedgEntry(ValueEntry, ItemLedgEntry) then                ItemLedgEntry.Modify();        end;        IsHandled := false;        OnInsertValueEntryOnBeforeShouldCalcExpectedCost(ItemJnlLine, ItemLedgEntry, ValueEntry, TransferItem, ShouldCalcExpectedCost, IsHandled);        if not IsHandled then begin            ShouldCalcExpectedCost :=                ((ValueEntry."Entry Type" = ValueEntry."Entry Type"::"Direct Cost") and                    (ValueEntry."Item Charge No." = '')) and                (((ItemJnlLine.Quantity = 0) and (ItemJnlLine."Invoiced Quantity" <> 0)) or                    (ItemJnlLine.Adjustment and not ValueEntry."Expected Cost")) and                not ExpectedCostPosted(ValueEntry);            OnInsertValueEntryOnBeforeCalcExpectedCost(ItemJnlLine, ItemLedgEntry, ValueEntry, TransferItem, InventoryPostingToGL, ShouldCalcExpectedCost);            if ShouldCalcExpectedCost then begin                if ValueEntry."Invoiced Quantity" = 0 then begin                    if InvdValueEntry.Get(ValueEntry."Applies-to Entry") then                        InvoicedQty := InvdValueEntry."Invoiced Quantity"                    else                        InvoicedQty := ValueEntry."Valued Quantity";                end else                    InvoicedQty := ValueEntry."Invoiced Quantity";                CalcExpectedCost(                  ValueEntry,                  ItemLedgEntry."Entry No.",                  InvoicedQty,                  ItemLedgEntry.Quantity,                  ValueEntry."Cost Amount (Expected)",                  ValueEntry."Cost Amount (Expected) (ACY)",                  ValueEntry."Sales Amount (Expected)",                  ValueEntry."Purchase Amount (Expected)",                  ItemLedgEntry.Quantity = ItemLedgEntry."Invoiced Quantity");            end;        end;        xValueEntryNo := ValueEntryNo;        OnBeforeInsertValueEntry(ValueEntry, ItemJnlLine, ItemLedgEntry, ValueEntryNo, InventoryPostingToGL, CalledFromAdjustment, OldItemLedgEntry, Item, TransferItem, GlobalValueEntry);        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");        PostInventoryToGL(ValueEntry);        InsertItemReg(0, 0, ValueEntry."Entry No.", 0);        ValueEntry."Item Register No." := ItemReg."No.";        ValueEntry.Insert(true);        xValueEntryNo := ValueEntryNo;        OnAfterInsertValueEntry(ValueEntry, ItemJnlLine, ItemLedgEntry, ValueEntryNo);        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");        ItemApplnEntry.SetOutboundsNotUpdated(ItemLedgEntry);        UpdateAdjmtProperties(ValueEntry, ItemLedgEntry."Posting Date");        OnInsertValueEntryOnBeforeInsertPostValueEntryToGL(ValueEntry);        InsertPostValueEntryToGL(ValueEntry);        OnInsertValueEntryOnAfterInsertPostValueEntryToGL(ValueEntry);        if Item."Item Tracking Code" <> '' then begin            TempValueEntryRelation.Init();            TempValueEntryRelation."Value Entry No." := ValueEntry."Entry No.";            TempValueEntryRelation.Insert();        end;        OnInsertValueEntryOnAfterTempValueEntryRelationInsert(ValueEntry, ItemJnlLine, TempValueEntryRelation);    end;    local procedure RecalculateCostPerUnit(var ValueEntry: Record "Value Entry"; var ItemLedgEntry: Record "Item Ledger Entry")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRecalculateCostPerUnit(ValueEntry, ItemJnlLine, ItemLedgEntry, IsHandled);        if IsHandled then            exit;        if ValueEntry."Cost per Unit" = 0 then begin            ValueEntry."Cost per Unit" :=              CalcCostPerUnit(ValueEntry."Cost Amount (Actual)", ValueEntry."Valued Quantity", false);            ValueEntry."Cost per Unit (ACY)" :=              CalcCostPerUnit(ValueEntry."Cost Amount (Actual) (ACY)", ValueEntry."Valued Quantity", true);        end else begin            ValueEntry."Cost per Unit" := Round(                ValueEntry."Cost per Unit", GLSetup."Unit-Amount Rounding Precision");            ValueEntry."Cost per Unit (ACY)" := Round(                ValueEntry."Cost per Unit (ACY)", Currency."Unit-Amount Rounding Precision");            if ItemJnlLine."Source Currency Code" = GLSetup."Additional Reporting Currency" then                if ValueEntry."Expected Cost" then                    ValueEntry."Cost per Unit" :=                      CalcCostPerUnit(ValueEntry."Cost Amount (Expected)", ValueEntry."Valued Quantity", false)                else                    if ValueEntry."Entry Type" = ValueEntry."Entry Type"::Revaluation then                        ValueEntry."Cost per Unit" :=                          CalcCostPerUnit(ValueEntry."Cost Amount (Actual)" + ValueEntry."Cost Amount (Expected)",                            ValueEntry."Valued Quantity", false)                    else                        if not ValueEntry.Inventoriable and (ValueEntry."Item Charge No." = '') then                            ValueEntry."Cost per Unit" :=                                CalcCostPerUnit(ValueEntry."Cost Amount (Non-Invtbl.)", ValueEntry."Valued Quantity", false)                        else                            ValueEntry."Cost per Unit" :=                              CalcCostPerUnit(ValueEntry."Cost Amount (Actual)", ValueEntry."Valued Quantity", false);        end;    end;    local procedure InsertOHValueEntry(ValueEntry: Record "Value Entry"; OverheadAmount: Decimal; OverheadAmountACY: Decimal)    var        xValueEntryNo: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertOHValueEntry(ValueEntry, Item, OverheadAmount, OverheadAmountACY, IsHandled);        if IsHandled then            exit;        if Item."Inventory Value Zero" or not ValueEntry.Inventoriable then            exit;        ValueEntryNo := GetNextValueEntryNo(ValueEntryNo);        ValueEntry."Entry No." := ValueEntryNo;        ValueEntry."Item Charge No." := '';        ValueEntry."Entry Type" := ValueEntry."Entry Type"::"Indirect Cost";        ValueEntry.Description := '';        ValueEntry."Cost per Unit" := 0;        ValueEntry."Cost per Unit (ACY)" := 0;        ValueEntry."Cost Posted to G/L" := 0;        ValueEntry."Cost Posted to G/L (ACY)" := 0;        ValueEntry."Invoiced Quantity" := 0;        ValueEntry."Sales Amount (Actual)" := 0;        ValueEntry."Sales Amount (Expected)" := 0;        ValueEntry."Purchase Amount (Actual)" := 0;        ValueEntry."Purchase Amount (Expected)" := 0;        ValueEntry."Discount Amount" := 0;        ValueEntry."Cost Amount (Actual)" := OverheadAmount;        ValueEntry."Cost Amount (Expected)" := 0;        ValueEntry."Cost Amount (Expected) (ACY)" := 0;        if GLSetup."Additional Reporting Currency" <> '' then            ValueEntry."Cost Amount (Actual) (ACY)" :=              Round(OverheadAmountACY, Currency."Amount Rounding Precision");        IsHandled := false;        xValueEntryNo := ValueEntryNo;        OnInsertOHValueEntryOnBeforeInsertValueEntry(ValueEntry, ItemJnlLine, IsHandled, GlobalItemLedgEntry, ValueEntryNo);        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");        if not IsHandled then            InsertValueEntry(ValueEntry, GlobalItemLedgEntry, false);        OnAfterInsertOHValueEntry(ValueEntry, Item, OverheadAmount, OverheadAmountACY);    end;    local procedure InsertVarValueEntry(ValueEntry: Record "Value Entry"; VarianceAmount: Decimal; VarianceAmountACY: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertVarValueEntry(ValueEntry, Item, VarianceAmount, VarianceAmountACY, IsHandled);        if IsHandled then            exit;        if (not ValueEntry.Inventoriable) or Item."Inventory Value Zero" then            exit;        if (VarianceAmount = 0) and (VarianceAmountACY = 0) then            exit;        ValueEntryNo := GetNextValueEntryNo(ValueEntryNo);        ValueEntry."Entry No." := ValueEntryNo;        ValueEntry."Item Charge No." := '';        ValueEntry."Entry Type" := ValueEntry."Entry Type"::Variance;        ValueEntry.Description := '';        ValueEntry."Cost Posted to G/L" := 0;        ValueEntry."Cost Posted to G/L (ACY)" := 0;        ValueEntry."Invoiced Quantity" := 0;        ValueEntry."Sales Amount (Actual)" := 0;        ValueEntry."Sales Amount (Expected)" := 0;        ValueEntry."Purchase Amount (Actual)" := 0;        ValueEntry."Purchase Amount (Expected)" := 0;        ValueEntry."Discount Amount" := 0;        ValueEntry."Cost Amount (Actual)" := VarianceAmount;        ValueEntry."Cost Amount (Expected)" := 0;        ValueEntry."Cost Amount (Expected) (ACY)" := 0;        ValueEntry."Variance Type" := ValueEntry."Variance Type"::Purchase;        OnInsertVarValueEntryOnAfterInitValueEntryFields(ValueEntry);        if GLSetup."Additional Reporting Currency" <> '' then            if Round(VarianceAmount, GLSetup."Amount Rounding Precision") =               Round(-GlobalValueEntry."Cost Amount (Actual)", GLSetup."Amount Rounding Precision")            then                ValueEntry."Cost Amount (Actual) (ACY)" := -GlobalValueEntry."Cost Amount (Actual) (ACY)"            else                ValueEntry."Cost Amount (Actual) (ACY)" :=                  Round(VarianceAmountACY, Currency."Amount Rounding Precision");        ValueEntry."Cost per Unit" :=          CalcCostPerUnit(ValueEntry."Cost Amount (Actual)", ValueEntry."Valued Quantity", false);        ValueEntry."Cost per Unit (ACY)" :=          CalcCostPerUnit(ValueEntry."Cost Amount (Actual) (ACY)", ValueEntry."Valued Quantity", true);        IsHandled := false;        OnInsertVarValueEntryOnBeforeInsertValueEntry(ValueEntry, GlobalItemLedgEntry, IsHandled, ItemJnlLine);        if IsHandled then            exit;        InsertValueEntry(ValueEntry, GlobalItemLedgEntry, false);    end;    local procedure UpdateItemLedgEntry(ValueEntry: Record "Value Entry"; var ItemLedgEntry: Record "Item Ledger Entry") ModifyEntry: Boolean    var        IsHandled: Boolean;    begin        if not (ValueEntry."Entry Type" in                [ValueEntry."Entry Type"::Variance,                 ValueEntry."Entry Type"::"Indirect Cost",                 ValueEntry."Entry Type"::Rounding])        then begin            IsHandled := false;            OnUpdateItemLedgEntryOnBeforeUpdateAvgCostAdjmtBuffer(ItemLedgEntry, ValueEntry."Valuation Date", IsHandled);            if not IsHandled then                if ValueEntry.Inventoriable and (not ItemJnlLine.Adjustment or (ItemLedgEntry."Entry Type" = ItemLedgEntry."Entry Type"::"Assembly Output")) then                    UpdateAvgCostAdjmtBuffer(ItemLedgEntry, ValueEntry."Valuation Date");            if (ItemLedgEntry.Positive or ItemLedgEntry."Job Purchase") and               (ItemLedgEntry.Quantity <> ItemLedgEntry."Remaining Quantity") and not ItemLedgEntry."Applied Entry to Adjust" and               (Item.Type = Item.Type::Inventory) and               (not CalledFromAdjustment or AppliedEntriesToReadjust(ItemLedgEntry))            then begin                ItemLedgEntry."Applied Entry to Adjust" := true;                ModifyEntry := true;                OnUpdateItemLedgerEntryOnAfterSetAppliedEntryToAdjust(ItemLedgEntry);            end;            if (ValueEntry."Entry Type" = ValueEntry."Entry Type"::"Direct Cost") and               (ItemJnlLine."Item Charge No." = '') and               (ItemJnlLine.Quantity = 0) and (ValueEntry."Invoiced Quantity" <> 0)            then begin                if ValueEntry."Invoiced Quantity" <> 0 then begin                    ItemLedgEntry."Invoiced Quantity" := ItemLedgEntry."Invoiced Quantity" + ValueEntry."Invoiced Quantity";                    CheckInvoicedQuantity(ItemLedgEntry, ValueEntry, ModifyEntry);                end;                if (ItemLedgEntry."Entry Type" <> ItemLedgEntry."Entry Type"::Output) and                   (ItemLedgEntry."Invoiced Quantity" = ItemLedgEntry.Quantity) and                   not ItemLedgEntry."Completely Invoiced"                then begin                    ItemLedgEntry."Completely Invoiced" := true;                    ModifyEntry := true;                end;                if ItemLedgEntry."Last Invoice Date" < ValueEntry."Posting Date" then begin                    ItemLedgEntry."Last Invoice Date" := ValueEntry."Posting Date";                    ModifyEntry := true;                end;            end;            IsHandled := false;            OnUpdateItemLedgEntryOnBeforeUpdateOutboundItemLedgEntry(ValueEntry, IsHandled, ItemJnlLine);            if not IsHandled then                if ItemJnlLine."Applies-from Entry" <> 0 then                    UpdateOutboundItemLedgEntry(ItemJnlLine."Applies-from Entry");        end;        exit(ModifyEntry);    end;    local procedure UpdateAvgCostAdjmtBuffer(OldItemLedgEntry: Record "Item Ledger Entry"; ValuationDate: Date)    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.Init();        ValueEntry."Item No." := OldItemLedgEntry."Item No.";        ValueEntry."Valuation Date" := ValuationDate;        ValueEntry."Location Code" := OldItemLedgEntry."Location Code";        ValueEntry."Variant Code" := OldItemLedgEntry."Variant Code";        OnUpdateAvgCostAdjmtBufferOnAfterSetValueEntry(ValueEntry, OldItemLedgEntry);        AvgCostEntryPointHandler.LockBuffer();        AvgCostEntryPointHandler.UpdateValuationDate(ValueEntry);        OnAfterUpdateAvgCostAdjmtBuffer(OldItemLedgEntry, ValueEntry, ValuationDate);    end;    local procedure UpdateOutboundItemLedgEntry(OutboundItemEntryNo: Integer)    var        OutboundItemLedgEntry: Record "Item Ledger Entry";    begin        OutboundItemLedgEntry.Get(OutboundItemEntryNo);        if OutboundItemLedgEntry.Quantity > 0 then            OutboundItemLedgEntry.FieldError(Quantity);        if GlobalItemLedgEntry.Quantity < 0 then            GlobalItemLedgEntry.FieldError(Quantity);        OutboundItemLedgEntry."Shipped Qty. Not Returned" := OutboundItemLedgEntry."Shipped Qty. Not Returned" + Abs(ItemJnlLine.Quantity);        if OutboundItemLedgEntry."Shipped Qty. Not Returned" > 0 then            OutboundItemLedgEntry.FieldError("Shipped Qty. Not Returned", Text004);        OutboundItemLedgEntry."Applied Entry to Adjust" := true;        OutboundItemLedgEntry.Modify();    end;    /// <summary>    /// Initializes a value entry record for a transfer item ledger entry.    /// Calculates the cost amounts and adjusted cost based on whether the average transfer is being used.    /// </summary>    /// <param name="ValueEntry">Return value: Initialized value entry.</param>    /// <param name="ItemLedgEntry">Item ledger entry to initialize value entry from.</param>    procedure InitTransValueEntry(var ValueEntry: Record "Value Entry"; ItemLedgEntry: Record "Item Ledger Entry")    var        AdjCostInvoicedLCY: Decimal;        AdjCostInvoicedACY: Decimal;        DiscountAmount: Decimal;        IsHandled: Boolean;    begin        InitValueEntry(ValueEntry, ItemLedgEntry);        OnInitTransValueEntryOnAfterInitValueEntry(ValueEntry, ItemLedgEntry);        ValueEntry."Valued Quantity" := ItemLedgEntry.Quantity;        ValueEntry."Invoiced Quantity" := ValueEntry."Valued Quantity";        ValueEntry."Location Code" := ItemLedgEntry."Location Code";        ValueEntry."Valuation Date" := GlobalValueEntry."Valuation Date";        if AverageTransfer then begin            ValuateAppliedAvgEntry(GlobalValueEntry, Item);            OnInitTransValueEntryOnBeforeCalcCostAmounts(GlobalValueEntry, ValueEntry, GlobalItemTrackingSetup, IsHandled);            if not IsHandled then begin                ValueEntry."Cost Amount (Actual)" := -GlobalValueEntry."Cost Amount (Actual)";                ValueEntry."Cost Amount (Actual) (ACY)" := -GlobalValueEntry."Cost Amount (Actual) (ACY)";            end;            ValueEntry."Cost per Unit" := 0;            ValueEntry."Cost per Unit (ACY)" := 0;            ValueEntry."Valued By Average Cost" :=                not (ItemLedgEntry.Positive or                    (ValueEntry."Document Type" = ValueEntry."Document Type"::"Transfer Receipt"));        end else begin            IsHandled := false;            OnInitTransValueEntryOnBeforeCalcAdjustedCost(OldItemLedgEntry, ValueEntry, AdjCostInvoicedLCY, AdjCostInvoicedACY, DiscountAmount, IsHandled);            if not IsHandled then begin                CalcAdjustedCost(                    OldItemLedgEntry, ValueEntry."Valued Quantity",                    AdjCostInvoicedLCY, AdjCostInvoicedACY, DiscountAmount);                ValueEntry."Cost Amount (Actual)" := AdjCostInvoicedLCY;                ValueEntry."Cost Amount (Actual) (ACY)" := AdjCostInvoicedACY;                ValueEntry."Cost per Unit" := 0;                ValueEntry."Cost per Unit (ACY)" := 0;            end;            OnInitTransValueEntryOnAfterCalcAdjustedCost(ValueEntry, GlobalValueEntry);            GlobalValueEntry."Cost Amount (Actual)" := GlobalValueEntry."Cost Amount (Actual)" - ValueEntry."Cost Amount (Actual)";            if GLSetup."Additional Reporting Currency" <> '' then                GlobalValueEntry."Cost Amount (Actual) (ACY)" :=                    CurrExchRate.ExchangeAmtLCYToFCY(                    ValueEntry."Posting Date", GLSetup."Additional Reporting Currency",                    Round(GlobalValueEntry."Cost Amount (Actual)", GLSetup."Amount Rounding Precision"),                    CurrExchRate.ExchangeRate(                        ValueEntry."Posting Date", GLSetup."Additional Reporting Currency"));        end;        GlobalValueEntry."Discount Amount" := 0;        ValueEntry."Discount Amount" := 0;        GlobalValueEntry."Cost per Unit" := 0;        GlobalValueEntry."Cost per Unit (ACY)" := 0;    end;    local procedure ValuateAppliedAvgEntry(var ValueEntry: Record "Value Entry"; Item: Record Item)    begin        if (ItemJnlLine."Applies-to Entry" = 0) and            (ValueEntry."Item Ledger Entry Type" <> ValueEntry."Item Ledger Entry Type"::Output)        then begin            if (ItemJnlLine.Quantity = 0) and (ItemJnlLine."Invoiced Quantity" <> 0) then begin                GetLastDirectCostValEntry(ValueEntry."Item Ledger Entry No.");                ValueEntry."Valued By Average Cost" := DirCostValueEntry."Valued By Average Cost";            end else                ValueEntry."Valued By Average Cost" := not (ValueEntry."Document Type" = ValueEntry."Document Type"::"Transfer Receipt");            if Item."Inventory Value Zero" then begin                ValueEntry."Cost per Unit" := 0;                ValueEntry."Cost per Unit (ACY)" := 0;            end else begin                if ValueEntry."Item Ledger Entry Type" = ValueEntry."Item Ledger Entry Type"::Transfer then begin                    if SKUExists and (InvtSetup."Average Cost Calc. Type" <> InvtSetup."Average Cost Calc. Type"::Item) then                        ValueEntry."Cost per Unit" := SKU."Unit Cost"                    else                        ValueEntry."Cost per Unit" := Item."Unit Cost";                end else                    ValueEntry."Cost per Unit" := ItemJnlLine."Unit Cost";                OnValuateAppliedAvgEntryOnAfterSetCostPerUnit(ValueEntry, ItemJnlLine, InvtSetup, SKU, SKUExists, Item);                if GLSetup."Additional Reporting Currency" <> '' then                    if (ItemJnlLine."Source Currency Code" = GLSetup."Additional Reporting Currency") and                       (ValueEntry."Item Ledger Entry Type" <> ValueEntry."Item Ledger Entry Type"::Transfer)                    then                        ValueEntry."Cost per Unit (ACY)" := ItemJnlLine."Unit Cost (ACY)"                    else                        ValueEntry."Cost per Unit (ACY)" :=                          Round(                            CurrExchRate.ExchangeAmtLCYToFCY(                              ValueEntry."Posting Date", GLSetup."Additional Reporting Currency", ValueEntry."Cost per Unit",                              CurrExchRate.ExchangeRate(                                ValueEntry."Posting Date", GLSetup."Additional Reporting Currency")),                            Currency."Unit-Amount Rounding Precision");            end;            OnValuateAppliedAvgEntryOnAfterUpdateCostAmounts(ValueEntry, ItemJnlLine);            if ValueEntry."Expected Cost" then begin                ValueEntry."Cost Amount (Expected)" := ValueEntry."Valued Quantity" * ValueEntry."Cost per Unit";                ValueEntry."Cost Amount (Expected) (ACY)" := ValueEntry."Valued Quantity" * ValueEntry."Cost per Unit (ACY)";            end else begin                ValueEntry."Cost Amount (Actual)" := ValueEntry."Valued Quantity" * ValueEntry."Cost per Unit";                ValueEntry."Cost Amount (Actual) (ACY)" := ValueEntry."Valued Quantity" * ValueEntry."Cost per Unit (ACY)";            end;        end;        OnAfterValuateAppliedAvgEntry(ValueEntry, ItemJnlLine)    end;    local procedure CalcAdjustedCost(PosItemLedgEntry: Record "Item Ledger Entry"; AppliedQty: Decimal; var AdjustedCostLCY: Decimal; var AdjustedCostACY: Decimal; var DiscountAmount: Decimal)    var        PosValueEntry: Record "Value Entry";    begin        AdjustedCostLCY := 0;        AdjustedCostACY := 0;        DiscountAmount := 0;        PosValueEntry.SetCurrentKey("Item Ledger Entry No.");        PosValueEntry.SetRange("Item Ledger Entry No.", PosItemLedgEntry."Entry No.");        PosValueEntry.FindSet();        repeat            if PosValueEntry."Partial Revaluation" then begin                AdjustedCostLCY := AdjustedCostLCY +                  PosValueEntry."Cost Amount (Actual)" / PosValueEntry."Valued Quantity" * PosItemLedgEntry.Quantity;                AdjustedCostACY := AdjustedCostACY +                  PosValueEntry."Cost Amount (Actual) (ACY)" / PosValueEntry."Valued Quantity" * PosItemLedgEntry.Quantity;            end else begin                AdjustedCostLCY := AdjustedCostLCY + PosValueEntry."Cost Amount (Actual)" + PosValueEntry."Cost Amount (Expected)";                AdjustedCostACY := AdjustedCostACY + PosValueEntry."Cost Amount (Actual) (ACY)" + PosValueEntry."Cost Amount (Expected) (ACY)";                DiscountAmount := DiscountAmount - PosValueEntry."Discount Amount";            end;        until PosValueEntry.Next() = 0;        AdjustedCostLCY := AdjustedCostLCY * AppliedQty / PosItemLedgEntry.Quantity;        AdjustedCostACY := AdjustedCostACY * AppliedQty / PosItemLedgEntry.Quantity;        DiscountAmount := DiscountAmount * AppliedQty / PosItemLedgEntry.Quantity;        OnAfterCalcAdjustedCost(ItemJnlLine, AdjustedCostLCY, AdjustedCostACY);    end;    local procedure GetMaxValuationDate(ItemLedgerEntry: Record "Item Ledger Entry"): Date    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type", "Entry No.");        ValueEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No.");        ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::Revaluation);        if not ValueEntry.FindLast() then begin            ValueEntry.SetRange("Entry Type");            ValueEntry.FindLast();        end;        exit(ValueEntry."Valuation Date");    end;    local procedure GetValuationDate(var ValueEntry: Record "Value Entry"; OldItemLedgEntry: Record "Item Ledger Entry")    var        OldValueEntry: Record "Value Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetValuationDate(OldItemLedgEntry, OldValueEntry."Valuation Date", IsHandled);        if IsHandled then            exit;        OldValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type", "Entry No.");        OldValueEntry.SetRange("Item Ledger Entry No.", OldItemLedgEntry."Entry No.");        OldValueEntry.SetRange("Entry Type", OldValueEntry."Entry Type"::Revaluation);        OnGetValuationDateOnAfterOldValueEntrySetFilters(OldValueEntry, ValueEntry, OldItemLedgEntry);        if not OldValueEntry.FindLast() then begin            OldValueEntry.SetRange("Entry Type");            IsHandled := false;            OnGetValuationDateOnBeforeFindOldValueEntry(OldValueEntry, IsHandled);            if IsHandled then                exit;            OldValueEntry.FindLast();        end;        if OldItemLedgEntry.Positive then begin            if (ValueEntry."Posting Date" < OldValueEntry."Valuation Date") or               (ItemJnlLine."Applies-to Entry" <> 0)            then begin                ValueEntry."Valuation Date" := OldValueEntry."Valuation Date";                SetValuationDateAllValueEntrie(                  ValueEntry."Item Ledger Entry No.",                  OldValueEntry."Valuation Date",                  ItemJnlLine."Applies-to Entry" <> 0)            end else                if ValueEntry."Valuation Date" <= ValueEntry."Posting Date" then begin                    ValueEntry."Valuation Date" := ValueEntry."Posting Date";                    SetValuationDateAllValueEntrie(                      ValueEntry."Item Ledger Entry No.",                      ValueEntry."Posting Date",                      ItemJnlLine."Applies-to Entry" <> 0)                end        end else            if OldValueEntry."Valuation Date" < ValueEntry."Valuation Date" then begin                UpdateAvgCostAdjmtBuffer(OldItemLedgEntry, OldValueEntry."Valuation Date");                OldValueEntry.ModifyAll("Valuation Date", ValueEntry."Valuation Date");                UpdateLinkedValuationDate(ValueEntry."Valuation Date", OldItemLedgEntry."Entry No.", OldItemLedgEntry.Positive);            end;    end;    local procedure UpdateLinkedValuationDate(FromValuationDate: Date; FromItemledgEntryNo: Integer; FromInbound: Boolean)    var        ToItemApplnEntry: Record "Item Application Entry";        ValuationDate: Date;        ValuationDateFound: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateLinkedValuationDate(GlobalItemLedgEntry, FromItemledgEntryNo, IsHandled);        if IsHandled then            exit;        if FromInbound then begin            ToItemApplnEntry.SetCurrentKey("Inbound Item Entry No.", "Item Ledger Entry No.", "Outbound Item Entry No.");            ToItemApplnEntry.SetRange("Inbound Item Entry No.", FromItemledgEntryNo);            ToItemApplnEntry.SetFilter("Outbound Item Entry No.", '<>%1', 0);        end else begin            ToItemApplnEntry.SetCurrentKey("Outbound Item Entry No.", "Item Ledger Entry No.");            ToItemApplnEntry.SetRange("Outbound Item Entry No.", FromItemledgEntryNo);        end;        ToItemApplnEntry.SetFilter("Item Ledger Entry No.", '<>%1', FromItemledgEntryNo);        if not FromInbound then            ToItemApplnEntry.SetFilter("Inbound Item Entry No.", '<>%1', 0);        if ToItemApplnEntry.FindSet() then            repeat                if not ValuationDateFound then begin                    GetLastDirectCostValEntry(ToItemApplnEntry."Inbound Item Entry No.");                    ValuationDate := DirCostValueEntry."Valuation Date";                    ValuationDateFound := true;                end;                if ValuationDate < FromValuationDate then begin                    UpdateValuationDate(FromValuationDate, ToItemApplnEntry."Item Ledger Entry No.", FromInbound);                    UpdateLinkedValuationDate(FromValuationDate, ToItemApplnEntry."Item Ledger Entry No.", not FromInbound);                end;            until ToItemApplnEntry.Next() = 0;    end;    local procedure UpdateLinkedValuationUnapply(FromValuationDate: Date; FromItemLedgEntryNo: Integer; FromInbound: Boolean)    var        ToItemApplnEntry: Record "Item Application Entry";        ItemLedgerEntry: Record "Item Ledger Entry";    begin        if FromInbound then begin            ToItemApplnEntry.SetCurrentKey("Inbound Item Entry No.", "Item Ledger Entry No.", "Outbound Item Entry No.");            ToItemApplnEntry.SetRange("Inbound Item Entry No.", FromItemLedgEntryNo);            ToItemApplnEntry.SetFilter("Outbound Item Entry No.", '<>%1', 0);        end else begin            ToItemApplnEntry.SetCurrentKey("Outbound Item Entry No.", "Item Ledger Entry No.");            ToItemApplnEntry.SetRange("Outbound Item Entry No.", FromItemLedgEntryNo);        end;        ToItemApplnEntry.SetFilter("Item Ledger Entry No.", '<>%1', FromItemLedgEntryNo);        if ToItemApplnEntry.Find('-') then            repeat                if FromInbound or (ToItemApplnEntry."Inbound Item Entry No." <> 0) then begin                    GetLastDirectCostValEntry(ToItemApplnEntry."Inbound Item Entry No.");                    if DirCostValueEntry."Valuation Date" < FromValuationDate then begin                        UpdateValuationDate(FromValuationDate, ToItemApplnEntry."Item Ledger Entry No.", FromInbound);                        UpdateLinkedValuationUnapply(FromValuationDate, ToItemApplnEntry."Item Ledger Entry No.", not FromInbound);                    end                    else begin                        ItemLedgerEntry.Get(ToItemApplnEntry."Inbound Item Entry No.");                        FromValuationDate := GetMaxAppliedValuationdate(ItemLedgerEntry);                        if FromValuationDate < DirCostValueEntry."Valuation Date" then begin                            UpdateValuationDate(FromValuationDate, ItemLedgerEntry."Entry No.", FromInbound);                            UpdateLinkedValuationUnapply(FromValuationDate, ItemLedgerEntry."Entry No.", not FromInbound);                        end;                    end;                end;            until ToItemApplnEntry.Next() = 0;    end;    local procedure UpdateValuationDate(FromValuationDate: Date; FromItemLedgEntryNo: Integer; FromInbound: Boolean)    var        ToValueEntry2: Record "Value Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateValuationDate(GlobalItemLedgEntry, FromItemLedgEntryNo, IsHandled);        if IsHandled then            exit;        ToValueEntry2.SetCurrentKey("Item Ledger Entry No.");        ToValueEntry2.SetRange("Item Ledger Entry No.", FromItemLedgEntryNo);        ToValueEntry2.Find('-');        if FromInbound then begin            if ToValueEntry2."Valuation Date" < FromValuationDate then                ToValueEntry2.ModifyAll("Valuation Date", FromValuationDate);        end else            repeat                if ToValueEntry2."Entry Type" = ToValueEntry2."Entry Type"::Revaluation then begin                    if ToValueEntry2."Valuation Date" < FromValuationDate then begin                        ToValueEntry2."Valuation Date" := FromValuationDate;                        ToValueEntry2.Modify();                    end;                end else begin                    ToValueEntry2."Valuation Date" := FromValuationDate;                    ToValueEntry2.Modify();                end;            until ToValueEntry2.Next() = 0;    end;    local procedure CreateItemJnlLineFromEntry(ItemLedgEntry: Record "Item Ledger Entry"; NewQuantity: Decimal; var ItemJnlLine: Record "Item Journal Line")    begin        Clear(ItemJnlLine);        ItemJnlLine."Entry Type" := ItemLedgEntry."Entry Type";        ItemJnlLine.Quantity := ItemJnlLine.Signed(NewQuantity);        ItemJnlLine."Item No." := ItemLedgEntry."Item No.";        ItemJnlLine.CopyTrackingFromItemLedgEntry(ItemLedgEntry);        OnAfterCreateItemJnlLineFromEntry(ItemJnlLine, ItemLedgEntry);    end;    local procedure GetAppliedFromValues(var ValueEntry: Record "Value Entry")    var        NegValueEntry: Record "Value Entry";    begin        NegValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type", "Entry No.");        NegValueEntry.SetRange("Item Ledger Entry No.", ItemJnlLine."Applies-from Entry");        NegValueEntry.SetRange("Entry Type", NegValueEntry."Entry Type"::Revaluation);        OnBeforeFindNegValueEntry(NegValueEntry);        if not NegValueEntry.FindLast() then begin            NegValueEntry.SetRange("Entry Type");            NegValueEntry.FindLast();        end;        if NegValueEntry."Valuation Date" > ValueEntry."Posting Date" then            ValueEntry."Valuation Date" := NegValueEntry."Valuation Date"        else            ValueEntry."Valuation Date" := ItemJnlLine."Posting Date";        OnAfterGetAppliedFromValues(ValueEntry, NegValueEntry);    end;    local procedure RoundAmtValueEntry(var ValueEntry: Record "Value Entry")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRoundAmtValueEntry(ValueEntry, Currency, Item, IsHandled);        if IsHandled then            exit;        ValueEntry."Sales Amount (Actual)" := Round(ValueEntry."Sales Amount (Actual)");        ValueEntry."Sales Amount (Expected)" := Round(ValueEntry."Sales Amount (Expected)");        ValueEntry."Purchase Amount (Actual)" := Round(ValueEntry."Purchase Amount (Actual)");        ValueEntry."Purchase Amount (Expected)" := Round(ValueEntry."Purchase Amount (Expected)");        ValueEntry."Discount Amount" := Round(ValueEntry."Discount Amount");        ValueEntry."Cost Amount (Actual)" := Round(ValueEntry."Cost Amount (Actual)");        ValueEntry."Cost Amount (Expected)" := Round(ValueEntry."Cost Amount (Expected)");        ValueEntry."Cost Amount (Non-Invtbl.)" := Round(ValueEntry."Cost Amount (Non-Invtbl.)");        ValueEntry."Cost Amount (Actual) (ACY)" := Round(ValueEntry."Cost Amount (Actual) (ACY)", Currency."Amount Rounding Precision");        ValueEntry."Cost Amount (Expected) (ACY)" := Round(ValueEntry."Cost Amount (Expected) (ACY)", Currency."Amount Rounding Precision");        ValueEntry."Cost Amount (Non-Invtbl.)(ACY)" := Round(ValueEntry."Cost Amount (Non-Invtbl.)(ACY)", Currency."Amount Rounding Precision");    end;    local procedure RetrieveCostPerUnit(ItemJnlLine: Record "Item Journal Line"; SKU: Record "Stockkeeping Unit"; SKUExists: Boolean): Decimal    var        UnitCost: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRetrieveCostPerUnit(ItemJnlLine, SKU, SKUExists, UnitCost, IsHandled);        if IsHandled then            exit(UnitCost);        if (Item."Costing Method" = Item."Costing Method"::Standard) and            (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and            (ItemJnlLine."Item Charge No." = '') and            (ItemJnlLine."Applies-from Entry" = 0) and            not ItemJnlLine.Adjustment        then begin            if SKUExists then                exit(SKU."Unit Cost");            exit(Item."Unit Cost");        end;        exit(ItemJnlLine."Unit Cost");    end;    local procedure RetrieveCostPerUnitACY(CostPerUnit: Decimal): Decimal    var        ItemLedgerEntry: Record "Item Ledger Entry";        PostingDate: Date;    begin        if ItemJnlLine.Adjustment or (ItemJnlLine."Source Currency Code" = GLSetup."Additional Reporting Currency") and           ((Item."Costing Method" <> Item."Costing Method"::Standard) or            ((ItemJnlLine."Discount Amount" = 0) and (ItemJnlLine."Indirect Cost %" = 0) and (ItemJnlLine."Overhead Rate" = 0)))        then            exit(ItemJnlLine."Unit Cost (ACY)");        if (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::Revaluation) and ItemLedgerEntry.Get(ItemJnlLine."Applies-to Entry") then            PostingDate := ItemLedgerEntry."Posting Date"        else            PostingDate := ItemJnlLine."Posting Date";        exit(Round(CurrExchRate.ExchangeAmtLCYToFCY(              PostingDate, GLSetup."Additional Reporting Currency",              CostPerUnit, CurrExchRate.ExchangeRate(                PostingDate, GLSetup."Additional Reporting Currency")),            Currency."Unit-Amount Rounding Precision"));    end;    local procedure CalcCostPerUnit(Cost: Decimal; Quantity: Decimal; IsACY: Boolean): Decimal    var        RndgPrec: Decimal;    begin        GetGLSetup();        if IsACY then            RndgPrec := Currency."Unit-Amount Rounding Precision"        else            RndgPrec := GLSetup."Unit-Amount Rounding Precision";        if Quantity <> 0 then            exit(Round(Cost / Quantity, RndgPrec));        exit(0);    end;    local procedure CalcPosShares(var DirCost: Decimal; var OvhdCost: Decimal; var PurchVar: Decimal; var DirCostACY: Decimal; var OvhdCostACY: Decimal; var PurchVarACY: Decimal; var CalcUnitCost: Boolean; CalcPurchVar: Boolean; Expected: Boolean)    var        CostCalcMgt: Codeunit "Cost Calculation Management";    begin        OnBeforeCalcPosShares(ItemJnlLine, Expected, CalcPurchVar);        if Expected then begin            if ShouldUseCumulativeRoundingForExpectedCost() then                DirCost := ItemJnlLine.Amount + Round(CostCalcMgt.CalcOvhdCost(ItemJnlLine.Amount, ItemJnlLine."Indirect Cost %", ItemJnlLine."Overhead Rate", ItemJnlLine.Quantity), GLSetup."Amount Rounding Precision") + RoundingResidualAmount            else                DirCost := ItemJnlLine."Unit Cost" * ItemJnlLine.Quantity + RoundingResidualAmount;            PurchVar := 0;            PurchVarACY := 0;            OvhdCost := 0;            OvhdCostACY := 0;        end else begin            OvhdCost :=              Round(                CostCalcMgt.CalcOvhdCost(                  ItemJnlLine.Amount, ItemJnlLine."Indirect Cost %", ItemJnlLine."Overhead Rate", ItemJnlLine."Invoiced Quantity"),                GLSetup."Amount Rounding Precision");            DirCost := ItemJnlLine.Amount;            if CalcPurchVar then                PurchVar := ItemJnlLine."Unit Cost" * ItemJnlLine."Invoiced Quantity" - DirCost - OvhdCost            else begin                PurchVar := 0;                PurchVarACY := 0;            end;        end;        if GLSetup."Additional Reporting Currency" <> '' then            if ShouldUseDocumentAmountForACY() then begin                if Expected then                    DirCostACY := ItemJnlLine."Unit Cost (ACY)" * ItemJnlLine.Quantity + RoundingResidualAmountACY                else                    DirCostACY := ItemJnlLine."Unit Cost (ACY)" * ItemJnlLine."Invoiced Quantity" + RoundingResidualAmountInvdACY;                OvhdCostACY := 0;                PurchVarACY := 0;            end else begin                DirCostACY := ACYMgt.CalcACYAmt(DirCost, ItemJnlLine."Posting Date", false);                OvhdCostACY := ACYMgt.CalcACYAmt(OvhdCost, ItemJnlLine."Posting Date", false);                ItemJnlLine."Unit Cost (ACY)" :=                  Round(                    CurrExchRate.ExchangeAmtLCYToFCY(                      ItemJnlLine."Posting Date", GLSetup."Additional Reporting Currency", ItemJnlLine."Unit Cost",                      CurrExchRate.ExchangeRate(                        ItemJnlLine."Posting Date", GLSetup."Additional Reporting Currency")),                    Currency."Unit-Amount Rounding Precision");                PurchVarACY := ItemJnlLine."Unit Cost (ACY)" * ItemJnlLine."Invoiced Quantity" - DirCostACY - OvhdCostACY;            end;        CalcUnitCost := (DirCost <> 0) and (ItemJnlLine."Unit Cost" = 0);        OnAfterCalcPosShares(ItemJnlLine, DirCost, OvhdCost, PurchVar, DirCostACY, OvhdCostACY, PurchVarACY, CalcUnitCost, CalcPurchVar, Expected, GlobalItemLedgEntry);    end;    local procedure ShouldUseDocumentAmountForACY(): Boolean    begin        exit(          (ItemJnlLine."Source Currency Code" = GLSetup."Additional Reporting Currency") and          (Item."Costing Method" <> Item."Costing Method"::Standard) and          (ItemJnlLine."Item Charge No." = '') and          (ItemJnlLine."Discount Amount" = 0) and          (ItemJnlLine."Indirect Cost %" = 0) and          (ItemJnlLine."Overhead Rate" = 0));    end;    local procedure CalcPurchCorrShares(var OverheadAmount: Decimal; var OverheadAmountACY: Decimal; var VarianceAmount: Decimal; var VarianceAmountACY: Decimal)    var        OldItemLedgEntry: Record "Item Ledger Entry";        OldValueEntry: Record "Value Entry";        CostAmt: Decimal;        CostAmtACY: Decimal;    begin        OldItemLedgEntry.ReadIsolation(IsolationLevel::ReadUncommitted);        OldValueEntry.ReadIsolation(IsolationLevel::ReadUncommitted);        OldValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type");        OldValueEntry.SetRange("Item Ledger Entry No.", ItemJnlLine."Applies-to Entry");        OldValueEntry.SetRange("Entry Type", OldValueEntry."Entry Type"::"Indirect Cost");        OldValueEntry.SetRange("Partial Revaluation", false);        OldValueEntry.CalcSums("Cost Amount (Actual)", "Cost Amount (Actual) (ACY)");        CostAmt := OldValueEntry."Cost Amount (Actual)";        CostAmtACY := OldValueEntry."Cost Amount (Actual) (ACY)";        if (CostAmt <> 0) or (CostAmtACY <> 0) then begin            OldItemLedgEntry.Get(ItemJnlLine."Applies-to Entry");            OverheadAmount := Round(                CostAmt / OldItemLedgEntry."Invoiced Quantity" * ItemJnlLine."Invoiced Quantity",                GLSetup."Amount Rounding Precision");            OverheadAmountACY := Round(                CostAmtACY / OldItemLedgEntry."Invoiced Quantity" * ItemJnlLine."Invoiced Quantity",                Currency."Unit-Amount Rounding Precision");            if Item."Costing Method" = Item."Costing Method"::Standard then begin                VarianceAmount := -OverheadAmount;                VarianceAmountACY := -OverheadAmountACY;            end else begin                VarianceAmount := 0;                VarianceAmountACY := 0;            end;        end else            if Item."Costing Method" = Item."Costing Method"::Standard then begin                OldValueEntry.SetRange("Partial Revaluation");                OldValueEntry.SetRange("Entry Type", OldValueEntry."Entry Type"::Variance);                VarianceRequired := not OldValueEntry.IsEmpty();            end;    end;    local procedure GetLastDirectCostValEntry(ItemLedgEntryNo: Integer)    var        Found: Boolean;    begin        if ItemLedgEntryNo = DirCostValueEntry."Item Ledger Entry No." then            exit;        DirCostValueEntry.Reset();        DirCostValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type", "Entry No.");        DirCostValueEntry.SetRange("Item Ledger Entry No.", ItemLedgEntryNo);        DirCostValueEntry.SetRange("Entry Type", DirCostValueEntry."Entry Type"::"Direct Cost");        DirCostValueEntry.SetFilter("Item Charge No.", '%1', '');        OnGetLastDirectCostValEntryOnBeforeFindDirCostValueEntry(DirCostValueEntry);        Found := DirCostValueEntry.FindLast();        DirCostValueEntry.SetRange("Item Charge No.");        if not Found then            DirCostValueEntry.FindLast();    end;    local procedure IsFirstValueEntry(ItemLedgEntryNo: Integer): Boolean    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.ReadIsolation(IsolationLevel::ReadUncommitted);        ValueEntry.SetCurrentKey("Item Ledger Entry No.");        ValueEntry.SetRange("Item Ledger Entry No.", ItemLedgEntryNo);        exit(ValueEntry.IsEmpty);    end;    local procedure CalcExpectedCost(var InvdValueEntry: Record "Value Entry"; ItemLedgEntryNo: Integer; InvoicedQty: Decimal; Quantity: Decimal; var ExpectedCost: Decimal; var ExpectedCostACY: Decimal; var ExpectedSalesAmt: Decimal; var ExpectedPurchAmt: Decimal; CalcReminder: Boolean)    var        ValueEntry: Record "Value Entry";    begin        ExpectedCost := 0;        ExpectedCostACY := 0;        ExpectedSalesAmt := 0;        ExpectedPurchAmt := 0;        ValueEntry.ReadIsolation(IsolationLevel::ReadUncommitted);        ValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type");        ValueEntry.SetRange("Item Ledger Entry No.", ItemLedgEntryNo);        ValueEntry.SetFilter("Entry Type", '<>%1', ValueEntry."Entry Type"::Revaluation);        OnCalcExpectedCostOnBeforeFindValueEntry(          ValueEntry, ItemLedgEntryNo, InvoicedQty, Quantity, ExpectedCost, ExpectedCostACY, ExpectedSalesAmt, ExpectedPurchAmt, CalcReminder, InvdValueEntry, ItemJnlLine);        if ValueEntry.FindSet() and ValueEntry."Expected Cost" then            if CalcReminder then begin                ValueEntry.CalcSums(                  "Cost Amount (Expected)", "Cost Amount (Expected) (ACY)",                  "Sales Amount (Expected)", "Purchase Amount (Expected)");                ExpectedCost := -ValueEntry."Cost Amount (Expected)";                ExpectedCostACY := -ValueEntry."Cost Amount (Expected) (ACY)";                if not CalledFromAdjustment then begin                    ExpectedSalesAmt := -ValueEntry."Sales Amount (Expected)";                    ExpectedPurchAmt := -ValueEntry."Purchase Amount (Expected)";                end            end else                if InvdValueEntry.Adjustment and                   (InvdValueEntry."Entry Type" = InvdValueEntry."Entry Type"::"Direct Cost")                then begin                    ExpectedCost := -InvdValueEntry."Cost Amount (Actual)";                    ExpectedCostACY := -InvdValueEntry."Cost Amount (Actual) (ACY)";                    if not CalledFromAdjustment then begin                        ExpectedSalesAmt := -InvdValueEntry."Sales Amount (Actual)";                        ExpectedPurchAmt := -InvdValueEntry."Purchase Amount (Actual)";                    end                end else begin                    repeat                        if ValueEntry."Expected Cost" and not ValueEntry.Adjustment then begin                            ExpectedCost := ExpectedCost + ValueEntry."Cost Amount (Expected)";                            ExpectedCostACY := ExpectedCostACY + ValueEntry."Cost Amount (Expected) (ACY)";                            if not CalledFromAdjustment then begin                                ExpectedSalesAmt := ExpectedSalesAmt + ValueEntry."Sales Amount (Expected)";                                ExpectedPurchAmt := ExpectedPurchAmt + ValueEntry."Purchase Amount (Expected)";                            end;                        end;                    until ValueEntry.Next() = 0;                    ExpectedCost :=                      CalcExpCostToBalance(ExpectedCost, InvoicedQty, Quantity, GLSetup."Amount Rounding Precision");                    ExpectedCostACY :=                      CalcExpCostToBalance(ExpectedCostACY, InvoicedQty, Quantity, Currency."Amount Rounding Precision");                    if not CalledFromAdjustment then begin                        ExpectedSalesAmt :=                          CalcExpCostToBalance(ExpectedSalesAmt, InvoicedQty, Quantity, GLSetup."Amount Rounding Precision");                        ExpectedPurchAmt :=                          CalcExpCostToBalance(ExpectedPurchAmt, InvoicedQty, Quantity, GLSetup."Amount Rounding Precision");                    end;                end;        OnAfterCalcExpectedCost(ValueEntry, ItemLedgEntryNo, ExpectedCost, ExpectedCostACY, ExpectedSalesAmt, ExpectedPurchAmt)    end;    local procedure CalcExpCostToBalance(ExpectedCost: Decimal; InvoicedQty: Decimal; Quantity: Decimal; RoundPrecision: Decimal): Decimal    begin        exit(-Round(InvoicedQty / Quantity * ExpectedCost, RoundPrecision));    end;    local procedure MoveValEntryDimToValEntryDim(var ToValueEntry: Record "Value Entry"; FromValueEntry: Record "Value Entry")    begin        ToValueEntry."Global Dimension 1 Code" := FromValueEntry."Global Dimension 1 Code";        ToValueEntry."Global Dimension 2 Code" := FromValueEntry."Global Dimension 2 Code";        ToValueEntry."Dimension Set ID" := FromValueEntry."Dimension Set ID";        OnAfterMoveValEntryDimToValEntryDim(ToValueEntry, FromValueEntry);    end;    /// <summary>    /// Updates reservation entries for the item ledger entry based on item order tracking requirements.    /// </summary>    /// <remarks>    /// If IsReserved parameter is false, and item doesn't have a tracking policy, reservations are not updated.    /// </remarks>    /// <param name="ItemLedgEntryRec">Item ledger entry to update reservation entries for.</param>    /// <param name="IsReserved">Indicates if the item ledger entry is reserved. </param>    procedure AutoTrack(var ItemLedgEntryRec: Record "Item Ledger Entry"; IsReserved: Boolean)    var        ReservMgt: Codeunit "Reservation Management";    begin        if Item."Order Tracking Policy" = Item."Order Tracking Policy"::None then begin            if not IsReserved then                exit;            // Ensure that Item Tracking is not left on the item ledger entry:            ReservMgt.SetReservSource(ItemLedgEntryRec);            ReservMgt.SetItemTrackingHandling(1);            ReservMgt.ClearSurplus();            exit;        end;        ReservMgt.SetReservSource(ItemLedgEntryRec);        ReservMgt.SetItemTrackingHandling(1);        ReservMgt.DeleteReservEntries(false, ItemLedgEntryRec."Remaining Quantity");        ReservMgt.ClearSurplus();        ReservMgt.AutoTrack(ItemLedgEntryRec."Remaining Quantity");    end;    /// <summary>    /// Sets the value of the global flag PostponeReservationHandling.    /// </summary>    /// <remarks>    /// Used to skip reservation handling functionality.    /// </remarks>    /// <param name="Postpone">The new value to set.</param>    procedure SetPostponeReservationHandling(Postpone: Boolean)    begin        // Used when posting Transfer Order receipts        PostponeReservationHandling := Postpone;    end;    local procedure SetupSplitJnlLine(var ItemJnlLine2: Record "Item Journal Line"; TrackingSpecExists: Boolean): Boolean    var        LateBindingMgt: Codeunit "Late Binding Management";        UOMMgt: Codeunit "Unit of Measure Management";        NonDistrQuantity: Decimal;        NonDistrAmount: Decimal;        NonDistrAmountACY: Decimal;        NonDistrDiscountAmount: Decimal;        SignFactor: Integer;        CalcWarrantyDate: Date;        CalcExpirationDate: Date;        Invoice: Boolean;        ExpirationDateChecked: Boolean;        PostItemJnlLine: Boolean;        IsHandled: Boolean;    begin        OnBeforeSetupSplitJnlLineProcedure(ItemJnlLine2, TrackingSpecExists, CalledFromAdjustment);        ItemJnlLineOrigin := ItemJnlLine2;        TempSplitItemJnlLine.Reset();        TempSplitItemJnlLine.DeleteAll();        DisableItemTracking := false;        OnSetupSplitJnlLineOnSetDisableItemTracking(ItemJnlLine2, DisableItemTracking);        Invoice := ItemJnlLine2."Invoiced Qty. (Base)" <> 0;        OnSetupSplitJnlLineOnAfterCalcInvoice(ItemJnlLine2, Invoice);        if (ItemJnlLine2."Entry Type" = ItemJnlLine2."Entry Type"::Transfer) and PostponeReservationHandling then            SignFactor := 1        else            SignFactor := ItemJnlLine2.Signed(1);        GlobalItemTrackingCode.Code := Item."Item Tracking Code";        OnSetupSplitJnlLineOnBeforeGetItemTrackingSetup(ItemJnlLine2, TrackingSpecExists, CalledFromAdjustment, Item, GlobalItemTrackingCode);        ItemTrackingMgt.GetItemTrackingSetup(            GlobalItemTrackingCode, ItemJnlLine."Entry Type",            ItemJnlLine.Signed(ItemJnlLine."Quantity (Base)") > 0, GlobalItemTrackingSetup);        OnSetupSplitJnlLineOnAfterGetItemTrackingSetup(GlobalItemTrackingCode, ItemJnlLine2, GlobalItemTrackingSetup, ItemJnlLine);        if Item."Costing Method" = Item."Costing Method"::Specific then begin            Item.TestField("Item Tracking Code");            GlobalItemTrackingCode.TestField("SN Specific Tracking", true);        end;        OnBeforeSetupSplitJnlLine(ItemJnlLine2, TrackingSpecExists, TempTrackingSpecification);        if not ItemJnlLine2.Correction and (ItemJnlLine2."Quantity (Base)" <> 0) and TrackingSpecExists then begin            if DisableItemTracking then begin                if not TempTrackingSpecification.IsEmpty() then                    OnSetupSplitJnlLineOnCheckOperationNo(ItemJnlLine2);            end else begin                if TempTrackingSpecification.IsEmpty() then                    Error(Text100);                CheckItemTrackingIsEmpty(ItemJnlLine2);                if Format(GlobalItemTrackingCode."Warranty Date Formula") <> '' then                    CalcWarrantyDate := CalcDate(GlobalItemTrackingCode."Warranty Date Formula", ItemJnlLine2."Document Date");                IsHandled := false;                OnBeforeCalcExpirationDate(ItemJnlLine2, CalcExpirationDate, IsHandled, Item);                if not IsHandled then                    if Format(Item."Expiration Calculation") <> '' then                        CalcExpirationDate := CalcDate(Item."Expiration Calculation", ItemJnlLine2."Document Date");                IsHandled := false;                OnSetupSplitJnlLineOnBeforeReallocateTrkgSpecification(GlobalItemTrackingCode, TempTrackingSpecification, ItemJnlLine2, SignFactor, IsHandled);                if not IsHandled then                    if SignFactor * ItemJnlLine2.Quantity < 0 then // Demand                        if GlobalItemTrackingCode."SN Specific Tracking" or GlobalItemTrackingCode."Lot Specific Tracking" then                            LateBindingMgt.ReallocateTrkgSpecification(TempTrackingSpecification);                TempTrackingSpecification.CalcSums(                  "Qty. to Handle (Base)", "Qty. to Invoice (Base)", "Qty. to Handle", "Qty. to Invoice");                TempTrackingSpecification.TestFieldError(TempTrackingSpecification.FieldCaption("Qty. to Handle (Base)"),                  TempTrackingSpecification."Qty. to Handle (Base)", SignFactor * ItemJnlLine2."Quantity (Base)");                if Invoice then                    TempTrackingSpecification.TestFieldError(TempTrackingSpecification.FieldCaption("Qty. to Invoice (Base)"),                      TempTrackingSpecification."Qty. to Invoice (Base)", SignFactor * ItemJnlLine2."Invoiced Qty. (Base)");                OnSetupSplitJnlLineOnBeforeCalcNonDistrQuantity(TempTrackingSpecification, ItemJnlLine2, Invoice, SignFactor);                NonDistrQuantity :=                    UOMMgt.CalcQtyFromBase(                        ItemJnlLine2."Item No.", ItemJnlLine2."Variant Code", ItemJnlLine2."Unit of Measure Code",                        UOMMgt.RoundQty(                            UOMMgt.CalcBaseQty(                                ItemJnlLine2."Item No.", ItemJnlLine2."Variant Code", ItemJnlLine2."Unit of Measure Code",                                ItemJnlLine2.Quantity, ItemJnlLine2."Qty. per Unit of Measure")),                    ItemJnlLine2."Qty. per Unit of Measure");                NonDistrAmount := ItemJnlLine2.Amount;                NonDistrAmountACY := ItemJnlLine2."Amount (ACY)";                NonDistrDiscountAmount := ItemJnlLine2."Discount Amount";                OnSetupSplitJnlLineOnBeforeSplitTempLines(TempSplitItemJnlLine, TempTrackingSpecification);                TempTrackingSpecification.FindSet();                repeat                    if GlobalItemTrackingCode."Man. Warranty Date Entry Reqd." then                        TempTrackingSpecification.TestField("Warranty Date");                    OnSetupSplitJnlLineOnBeforeCheckUseExpirationDates(ItemJnlLine2, TempTrackingSpecification, Item, CalcExpirationDate);                    if GlobalItemTrackingCode."Use Expiration Dates" then                        CheckExpirationDate(ItemJnlLine2, SignFactor, CalcExpirationDate, ExpirationDateChecked);                    OnSetupSplitJnlLineOnAfterCheckExpirationDate(ItemJnlLine2, TempTrackingSpecification, Item);                    CheckItemTrackingInformation(                        ItemJnlLine2, TempTrackingSpecification, SignFactor, GlobalItemTrackingCode, GlobalItemTrackingSetup);                    if TempTrackingSpecification."Warranty Date" = 0D then                        TempTrackingSpecification."Warranty Date" := CalcWarrantyDate;                    TempTrackingSpecification.Modify();                    TempSplitItemJnlLine := ItemJnlLine2;                    PostItemJnlLine :=                      PostItemJnlLine or                      SetupTempSplitItemJnlLine(                        ItemJnlLine2, SignFactor, NonDistrQuantity, NonDistrAmount,                        NonDistrAmountACY, NonDistrDiscountAmount, Invoice);                    OnSetupSplitJnlLineOnAfterSetupTempSplitItemJnlLine(ItemJnlLine2, TempSplitItemJnlLine, TempTrackingSpecification);                until TempTrackingSpecification.Next() = 0;            end;        end else            InsertTempSplitItemJnlLine(ItemJnlLine2, PostItemJnlLine);        OnAfterSetupSplitJnlLine(            ItemJnlLine2, TempSplitItemJnlLine, ItemJnlLineOrigin, TempTrackingSpecification,            TrackingSpecExists, CalledFromAdjustment, PostponeReservationHandling, PostItemJnlLine);        exit(PostItemJnlLine);    end;    local procedure InsertTempSplitItemJnlLine(ItemJnlLine2: Record "Item Journal Line"; var PostItemJnlLine: Boolean)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertTempSplitItemJnlLine(ItemJnlLine2, IsServUndoConsumption, PostponeReservationHandling, TempSplitItemJnlLine, IsHandled, PostItemJnlLine);        if IsHandled then            exit;        TempSplitItemJnlLine := ItemJnlLine2;        TempSplitItemJnlLine.Insert();        OnAfterInsertTempSplitItemJnlLine(TempSplitItemJnlLine, ItemJnlLine2)    end;    local procedure SplitItemJnlLine(var ItemJnlLine2: Record "Item Journal Line"; PostItemJnlLine: Boolean): Boolean    var        FreeEntryNo: Integer;        JnlLineNo: Integer;        SignFactor: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnSplitItemJnlLineOnBeforeTracking(            ItemJnlLine2, PostItemJnlLine, TempTrackingSpecification, GlobalItemLedgEntry, TempItemEntryRelation,            PostponeReservationHandling, SignFactor, IsHandled);        if not IsHandled then            if (ItemJnlLine2."Quantity (Base)" <> 0) and ItemJnlLine2.TrackingExists() then begin                if (ItemJnlLine2."Entry Type" in                    [ItemJnlLine2."Entry Type"::Sale,                    ItemJnlLine2."Entry Type"::"Negative Adjmt.",                    ItemJnlLine2."Entry Type"::Consumption,                    ItemJnlLine2."Entry Type"::"Assembly Consumption"]) or                ((ItemJnlLine2."Entry Type" = ItemJnlLine2."Entry Type"::Transfer) and                    not PostponeReservationHandling)                then                    SignFactor := -1                else                    SignFactor := 1;                TempTrackingSpecification.SetTrackingFilterFromItemJnlLine(ItemJnlLine2);                if TempTrackingSpecification.FindFirst() then begin                    FreeEntryNo := TempTrackingSpecification."Entry No.";                    TempTrackingSpecification.Delete();                    ItemJnlLine2.CheckTrackingEqualTrackingSpecification(TempTrackingSpecification);                    TempTrackingSpecification."Quantity (Base)" := SignFactor * ItemJnlLine2."Quantity (Base)";                    TempTrackingSpecification."Quantity Handled (Base)" := SignFactor * ItemJnlLine2."Quantity (Base)";                    TempTrackingSpecification."Quantity actual Handled (Base)" := SignFactor * ItemJnlLine2."Quantity (Base)";                    TempTrackingSpecification."Quantity Invoiced (Base)" := SignFactor * ItemJnlLine2."Invoiced Qty. (Base)";                    TempTrackingSpecification."Qty. to Invoice (Base)" :=                    SignFactor * (ItemJnlLine2."Quantity (Base)" - ItemJnlLine2."Invoiced Qty. (Base)");                    TempTrackingSpecification."Qty. to Handle (Base)" := 0;                    TempTrackingSpecification."Qty. to Handle" := 0;                    TempTrackingSpecification."Qty. to Invoice" :=                    SignFactor * (ItemJnlLine2.Quantity - ItemJnlLine2."Invoiced Quantity");                    TempTrackingSpecification."Item Ledger Entry No." := GlobalItemLedgEntry."Entry No.";                    TempTrackingSpecification."Transfer Item Entry No." := TempItemEntryRelation."Item Entry No.";                    OnSplitItemJnlLineOnBeforePostItemJnlLine(TempTrackingSpecification, GlobalItemLedgEntry);                    if PostItemJnlLine then                        TempTrackingSpecification."Entry No." := TempTrackingSpecification."Item Ledger Entry No.";                    OnSplitItemJnlLineOnBeforeInsertTempTrkgSpecification(TempTrackingSpecification, ItemJnlLine2, SignFactor);                    InsertTempTrkgSpecification(FreeEntryNo);                end else                    if (ItemJnlLine2."Item Charge No." = '') and (ItemJnlLine2."Job No." = '') then                        if not ItemJnlLine2.Correction then begin // Undo quantity posting                            IsHandled := false;                            OnBeforeTrackingSpecificationMissingErr(ItemJnlLine2, IsHandled);                            if not IsHandled then                                Error(TrackingSpecificationMissingErr);                        end;            end;        if TempSplitItemJnlLine.FindFirst() then begin            JnlLineNo := ItemJnlLine2."Line No.";            ItemJnlLine2 := TempSplitItemJnlLine;            ItemJnlLine2."Line No." := JnlLineNo;            TempSplitItemJnlLine.Delete();            OnSplitItemJnlLineOnAfterDeleteTempSplitItemJnlLine(ItemJnlLine2, CalledFromAdjustment);            exit(true);        end;        if ItemJnlLine."Phys. Inventory" then            InsertPhysInventoryEntry(ItemJnlLineOrigin);        exit(false);    end;    /// <summary>    /// Copies all tracking specification lines from the global variable to the parameter, overriding all existing lines.     /// After the transfer, all lines are deleted from the global record set.    /// </summary>    /// <remakrs>    /// Global and the provided target tracking specification record set is deleted.    /// </remakrs>    /// <param name="TargetTrackingSpecification">Return value: Copied tracking specification lines.</param>    /// <returns>True if any tracking specifications were transferred, otherwise false.</returns>    procedure CollectTrackingSpecification(var TargetTrackingSpecification: Record "Tracking Specification" temporary) Result: Boolean    var        IsHandled: Boolean;    begin        OnBeforeCollectTrackingSpecification(TempTrackingSpecification, TargetTrackingSpecification, Result, IsHandled);        if IsHandled then            exit(Result);        TempTrackingSpecification.Reset();        TargetTrackingSpecification.Reset();        TargetTrackingSpecification.DeleteAll();        if TempTrackingSpecification.FindSet() then            repeat                TargetTrackingSpecification := TempTrackingSpecification;                TargetTrackingSpecification.Insert();            until TempTrackingSpecification.Next() = 0        else            exit(false);        TempTrackingSpecification.DeleteAll();        exit(true);    end;    /// <summary>    /// Copies all value entry relation lines from the global variable to the parameter, overriding all existing lines.     /// After the transfer, all lines are deleted from the global record set.    /// </summary>    /// <remakrs>    /// Global value entry relation record set is deleted after the transfer.    /// </remakrs>    /// <param name="TargetValueEntryRelation">Return value: Copied value entry relations lines.</param>    /// <param name="RowId">Unique identifier text of a line that will be used in source rowId field.</param>    /// <returns>True if any value entry relations were transferred, otherwise false.</returns>    procedure CollectValueEntryRelation(var TargetValueEntryRelation: Record "Value Entry Relation" temporary; RowId: Text[250]) Result: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCollectValueEntryRelation(TempValueEntryRelation, TargetValueEntryRelation, Result, IsHandled);        if IsHandled then            exit(Result);        TempValueEntryRelation.Reset();        TargetValueEntryRelation.Reset();        if TempValueEntryRelation.FindSet() then            repeat                TargetValueEntryRelation := TempValueEntryRelation;                TargetValueEntryRelation."Source RowId" := RowId;                TargetValueEntryRelation.Insert();            until TempValueEntryRelation.Next() = 0        else            exit(false);        TempValueEntryRelation.DeleteAll();        exit(true);    end;    /// <summary>    /// Copies all item entry relation lines from the global variable to the parameter, overriding all existing lines.     /// After the transfer, all lines are deleted from the global record set.    /// </summary>    /// <remakrs>    /// Global item entry relation record set is deleted after the transfer.    /// </remakrs>    /// <param name="TargetItemEntryRelation">Return value: Copied item entry relation lines.</param>    /// <returns>True if any item entry relation lines were transferred, otherwise false.</returns>    procedure CollectItemEntryRelation(var TargetItemEntryRelation: Record "Item Entry Relation" temporary) Result: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCollectItemEntryRelation(TempItemEntryRelation, TargetItemEntryRelation, Result, IsHandled);        if IsHandled then            exit(Result);        TempItemEntryRelation.Reset();        TargetItemEntryRelation.Reset();        if TempItemEntryRelation.FindSet() then            repeat                TargetItemEntryRelation := TempItemEntryRelation;                TargetItemEntryRelation.Insert();            until TempItemEntryRelation.Next() = 0        else            exit(false);        TempItemEntryRelation.DeleteAll();        exit(true);    end;    local procedure CheckExpirationDate(var ItemJnlLine2: Record "Item Journal Line"; SignFactor: Integer; CalcExpirationDate: Date; var ExpirationDateChecked: Boolean)    var        ItemTrackingSetup: Record "Item Tracking Setup";        ExistingExpirationDate: Date;        EntriesExist: Boolean;        SumOfEntries: Decimal;        SumLot: Decimal;        IsHandled: Boolean;        SkipNewExpirationDateCheck: Boolean;    begin        IsHandled := false;        OnBeforeCheckExpirationDate(          ItemJnlLine2, TempTrackingSpecification, SignFactor, CalcExpirationDate, ExpirationDateChecked, IsHandled);        if IsHandled then            exit;        ExistingExpirationDate :=          ItemTrackingMgt.ExistingExpirationDate(TempTrackingSpecification, true, EntriesExist);        if not (EntriesExist or ExpirationDateChecked) then begin            ItemTrackingMgt.TestExpDateOnTrackingSpec(TempTrackingSpecification);            ExpirationDateChecked := true;        end;        IsHandled := false;        OnCheckExpirationDateOnBeforeAssignExpirationDate(TempTrackingSpecification, ExistingExpirationDate, IsHandled, GlobalItemTrackingCode, ItemJnlLine2, SignFactor);        if not IsHandled then            if ItemJnlLine2."Entry Type" = ItemJnlLine2."Entry Type"::Transfer then                if TempTrackingSpecification."Expiration Date" = 0D then                    TempTrackingSpecification."Expiration Date" := ExistingExpirationDate;        // Supply        if SignFactor * ItemJnlLine2.Quantity > 0 then begin        // Only expiration dates on supply.            if not (ItemJnlLine2."Entry Type" = ItemJnlLine2."Entry Type"::Transfer) then                if GlobalItemTrackingCode."Man. Expir. Date Entry Reqd." then begin                    if ItemJnlLine2."Phys. Inventory" and (ExistingExpirationDate <> 0D) then                        TempTrackingSpecification."Expiration Date" := ExistingExpirationDate;                    if not TempTrackingSpecification.Correction then                        if TempTrackingSpecification."Appl.-from Item Entry" = 0 then                            TempTrackingSpecification.TestField("Expiration Date");                end;            if CalcExpirationDate <> 0D then                if ExistingExpirationDate <> 0D then                    CalcExpirationDate := ExistingExpirationDate;            if ItemJnlLine2."Entry Type" = ItemJnlLine2."Entry Type"::Transfer then                if TempTrackingSpecification."New Expiration Date" = 0D then                    TempTrackingSpecification."New Expiration Date" := ExistingExpirationDate;            if TempTrackingSpecification."Expiration Date" = 0D then                TempTrackingSpecification."Expiration Date" := CalcExpirationDate;            OnCheckExpirationDateOnBeforeTestFieldExpirationDate(TempTrackingSpecification, EntriesExist, ExistingExpirationDate);            if EntriesExist then                TempTrackingSpecification.TestField("Expiration Date", ExistingExpirationDate);            if (ItemJnlLine2."Entry Type" = ItemJnlLine2."Entry Type"::Transfer) and (ItemJnlLine2."Order Type" = ItemJnlLine2."Order Type"::Transfer) then begin                GetExistingExpirationDateFromILE(ItemTrackingSetup, ExistingExpirationDate, SumOfEntries);                if TempTrackingSpecification."New Serial No." <> '' then                    SumLot := SignFactor * ItemTrackingMgt.SumNewLotOnTrackingSpec(TempTrackingSpecification)                else                    SumLot := SignFactor * TempTrackingSpecification."Quantity (Base)";                if (SumOfEntries > 0) and                   ((SumOfEntries <> SumLot) or (TempTrackingSpecification."New Lot No." <> TempTrackingSpecification."Lot No."))                then                    TempTrackingSpecification.TestField("New Expiration Date", ExistingExpirationDate);            end;        end else   // Demand            if ItemJnlLine2."Entry Type" = ItemJnlLine2."Entry Type"::Transfer then begin                GetExistingExpirationDateFromILE(ItemTrackingSetup, ExistingExpirationDate, SumOfEntries);                if (ItemJnlLine2."Order Type" = ItemJnlLine2."Order Type"::Transfer) and                   (ItemJnlLine2."Order No." <> '')                then                    if TempTrackingSpecification."New Expiration Date" = 0D then                        TempTrackingSpecification."New Expiration Date" := ExistingExpirationDate;                OnCheckExpirationDateOnBeforeTestNewLotNo(ItemJnlLine2, TempTrackingSpecification, ExistingExpirationDate, SumOfEntries);                if (TempTrackingSpecification."New Lot No." <> '') and                   ((ItemJnlLine2."Order Type" <> ItemJnlLine2."Order Type"::Transfer) or                    (ItemJnlLine2."Order No." = ''))                then begin                    if TempTrackingSpecification."New Serial No." <> '' then                        SumLot := SignFactor * ItemTrackingMgt.SumNewLotOnTrackingSpec(TempTrackingSpecification)                    else                        SumLot := SignFactor * TempTrackingSpecification."Quantity (Base)";                    SkipNewExpirationDateCheck := false;                    OnCheckExpirationDateOnAfterCalcSumLot(SumLot, SignFactor, TempTrackingSpecification, SkipNewExpirationDateCheck);                    if (not SkipNewExpirationDateCheck) and (SumOfEntries > 0) and                       ((SumOfEntries <> SumLot) or (TempTrackingSpecification."New Lot No." <> TempTrackingSpecification."Lot No.")                       or (TempTrackingSpecification."New Package No." <> TempTrackingSpecification."Package No."))                    then                        TempTrackingSpecification.TestField("New Expiration Date", ExistingExpirationDate);                    ItemTrackingMgt.TestExpDateOnTrackingSpecNew(TempTrackingSpecification);                end;            end;        if (ItemJnlLine2."Entry Type" = ItemJnlLine2."Entry Type"::Transfer) and           ((ItemJnlLine2."Order Type" <> ItemJnlLine2."Order Type"::Transfer) or            (ItemJnlLine2."Order No." = ''))        then            if GlobalItemTrackingCode."Man. Expir. Date Entry Reqd." then                TempTrackingSpecification.TestField("New Expiration Date");    end;    local procedure GetGLSetup()    begin        if not GLSetupRead then begin            GLSetup.Get();            if GLSetup."Additional Reporting Currency" <> '' then begin                Currency.Get(GLSetup."Additional Reporting Currency");                Currency.TestField("Unit-Amount Rounding Precision");                Currency.TestField("Amount Rounding Precision");            end;        end;        GLSetupRead := true;        OnAfterGetGLSetup(GLSetup);    end;    local procedure GetGeneralPostingSetup(ItemJournalLine: Record "Item Journal Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetGeneralPostingSetup(ItemJournalLine, GenPostingSetup, PostToGL, IsHandled);        if IsHandled then            exit;        if (ItemJournalLine."Gen. Bus. Posting Group" <> GenPostingSetup."Gen. Bus. Posting Group") or            (ItemJournalLine."Gen. Prod. Posting Group" <> GenPostingSetup."Gen. Prod. Posting Group")        then begin            GenPostingSetup.Get(ItemJournalLine."Gen. Bus. Posting Group", ItemJournalLine."Gen. Prod. Posting Group");            GenPostingSetup.TestField(Blocked, false);        end;    end;    local procedure GetInvtSetup()    begin        if not InvtSetupRead then begin            InvtSetup.Get();            SourceCodeSetup.Get();        end;        InvtSetupRead := true;    end;    local procedure RedirectInvoicingValuationDateToPostingDate(var ValueEntry: Record "Value Entry")    var        EarliestAllowedValDate: Date;    begin        if CalledFromAdjustment then            exit;        if not IsPureInvoicing() then            exit;        GetInvtSetup();        EarliestAllowedValDate := InvtSetup."Earliest Allowed Val. Date";        if EarliestAllowedValDate = 0D then            exit;        if (ValueEntry."Valuation Date" < EarliestAllowedValDate) and           (ItemJnlLine."Posting Date" >= EarliestAllowedValDate)        then            ValueEntry."Valuation Date" := ItemJnlLine."Posting Date";    end;    local procedure IsPureInvoicing(): Boolean    begin        exit(            (ItemJnlLine.Quantity = 0) and            (ItemJnlLine."Invoiced Quantity" <> 0) and            (ItemJnlLine."Item Charge No." = '') and            not ItemJnlLine.Adjustment and            (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost"));    end;    local procedure CheckValuationDateAllowed(ValueEntry: Record "Value Entry")    var        EarliestAllowedValuationDate: Date;    begin        if CalledFromAdjustment then            exit;        if IsExemptFromValuationDateCheck() then            exit;        GetInvtSetup();        EarliestAllowedValuationDate := InvtSetup."Earliest Allowed Val. Date";        if EarliestAllowedValuationDate = 0D then            exit;        if ValueEntry."Valuation Date" < EarliestAllowedValuationDate then            if (ItemJnlLine."Applies-to Entry" <> 0) or (ItemJnlLine."Applies-from Entry" <> 0) then                Error(                    ApplyToEntryValuationDateErr,                    GetAppliedEntryNo(),                    ValueEntry."Valuation Date",                    EarliestAllowedValuationDate)            else                Error(                    ValuationDateBeforeEarliestAllowedErr,                    ValueEntry."Valuation Date",                    EarliestAllowedValuationDate);    end;    local procedure IsExemptFromValuationDateCheck(): Boolean    begin        exit(            ItemJnlLine.Adjustment or            (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::Rounding));    end;    local procedure GetAppliedEntryNo(): Integer    begin        if ItemJnlLine."Applies-to Entry" <> 0 then            exit(ItemJnlLine."Applies-to Entry");        exit(ItemJnlLine."Applies-from Entry");    end;    local procedure UndoQuantityPosting()    var        OldItemLedgEntry: Record "Item Ledger Entry";        OldItemLedgEntry2: Record "Item Ledger Entry";        NewItemLedgEntry: Record "Item Ledger Entry";        OldValueEntry: Record "Value Entry";        NewValueEntry: Record "Value Entry";        IsReserved: Boolean;        IsHandled: Boolean;        ShouldInsertCorrValueEntries: Boolean;        ShouldCheckItem: Boolean;    begin        IsHandled := false;        OnBeforeUndoQuantityPosting(ItemJnlLine, IsHandled);        if IsHandled then            exit;        if ItemJnlLine."Entry Type" in [ItemJnlLine."Entry Type"::"Assembly Consumption",                                        ItemJnlLine."Entry Type"::"Assembly Output"]        then            exit;        if ItemJnlLine."Applies-to Entry" <> 0 then begin            OldItemLedgEntry.Get(ItemJnlLine."Applies-to Entry");            IsHandled := false;            OnUndoQuantityPostingOnBeforeCheckPositive(ItemJnlLine, OldItemLedgEntry, IsHandled);            if not IsHandled then                if not OldItemLedgEntry.Positive then                    ItemJnlLine."Applies-from Entry" := ItemJnlLine."Applies-to Entry";        end else            OldItemLedgEntry.Get(ItemJnlLine."Applies-from Entry");        if GetItem(OldItemLedgEntry."Item No.", false) then begin            ShouldCheckItem := true;            OnUndoQuantityPostingOnBeforeCheckItem(Item, OldItemLedgEntry, ShouldCheckItem);            if ShouldCheckItem then begin                Item.TestField(Blocked, false);                Item.CheckBlockedByApplWorksheet();                if GetItemVariant(OldItemLedgEntry."Item No.", OldItemLedgEntry."Variant Code", false) then                    ItemVariant.TestField(Blocked, false);            end;        end;        ItemJnlLine."Item No." := OldItemLedgEntry."Item No.";        OnUndoQuantityPostingOnBeforeInitCorrItemLedgEntry(ItemJnlLine, OldItemLedgEntry);        InitCorrItemLedgEntry(OldItemLedgEntry, NewItemLedgEntry);   // also inserts        OnUndoQuantityPostingOnAfterInitCorrItemLedgEntry(OldItemLedgEntry, NewItemLedgEntry);        if Item.IsNonInventoriableType() then begin            NewItemLedgEntry."Remaining Quantity" := 0;            NewItemLedgEntry.Open := false;        end;        OnUndoQuantityPostingOnAfterInsertItemReg(ItemJnlLine, OldItemLedgEntry, NewItemLedgEntry);        GlobalItemLedgEntry := NewItemLedgEntry;        CalcILEExpectedAmount(OldValueEntry, OldItemLedgEntry."Entry No.");        if OldValueEntry.Inventoriable then            AvgCostEntryPointHandler.UpdateValuationDate(OldValueEntry);        ShouldInsertCorrValueEntries := OldItemLedgEntry."Invoiced Quantity" = 0;        OnUndoQuantityPostingOnAfterCalcShouldInsertCorrValueEntry(OldItemLedgEntry, ShouldInsertCorrValueEntries);        if ShouldInsertCorrValueEntries then begin            IsHandled := false;            OnUndoQuantityPostingOnBeforeInsertCorrOldItemLedgEntry(OldItemLedgEntry, IsHandled);            if not IsHandled then                InsertCorrValueEntry(                OldValueEntry, NewValueEntry, OldItemLedgEntry, OldValueEntry."Document Line No.", 1,                0, OldItemLedgEntry.Quantity);            InsertCorrValueEntry(              OldValueEntry, NewValueEntry, NewItemLedgEntry, ItemJnlLine."Document Line No.", -1,              NewItemLedgEntry.Quantity, 0);            InsertCorrValueEntry(              OldValueEntry, NewValueEntry, NewItemLedgEntry, ItemJnlLine."Document Line No.", -1,              0, NewItemLedgEntry.Quantity);        end else            InsertCorrValueEntry(              OldValueEntry, NewValueEntry, NewItemLedgEntry, ItemJnlLine."Document Line No.", -1,              NewItemLedgEntry.Quantity, NewItemLedgEntry.Quantity);        OnUndoQuantityPostingOnBeforeUpdateOldItemLedgEntry(OldValueEntry, NewItemLedgEntry, NewValueEntry, ItemJnlLine);        UpdateOldItemLedgEntry(OldItemLedgEntry, NewItemLedgEntry."Posting Date");        UpdateItemApplnEntry(OldItemLedgEntry."Entry No.", NewItemLedgEntry."Posting Date");        OnUndoQuantityPostingOnAfterUpdateItemApplnEntry(ItemJnlLine, OldItemLedgEntry, NewItemLedgEntry, NewValueEntry, InventoryPostingToGL);        if GlobalItemLedgEntry.Quantity > 0 then            IsReserved :=              ItemJnlLineReserve.TransferItemJnlToItemLedgEntry(                ItemJnlLine, GlobalItemLedgEntry, ItemJnlLine."Quantity (Base)", true);        if not ItemJnlLine.IsATOCorrection() then begin            ApplyItemLedgEntry(NewItemLedgEntry, OldItemLedgEntry2, NewValueEntry, false);            OnUndoQuantityPostingOnBeforeAutoTrack(NewItemLedgEntry);            AutoTrack(NewItemLedgEntry, IsReserved);            OnUndoQuantityPostingOnAfterAutoTrack(NewItemLedgEntry, NewValueEntry, ItemJnlLine, Item);        end;        NewItemLedgEntry.Modify();        UpdateAdjmtProperties(NewValueEntry, NewItemLedgEntry."Posting Date");        OnUndoQuantityPostingOnBeforeInsertApplEntry(NewItemLedgEntry, OldItemLedgEntry, GlobalItemLedgEntry);        if NewItemLedgEntry.Positive then begin            UpdateOrigAppliedFromEntry(OldItemLedgEntry."Entry No.");            OldItemLedgEntry.SetAppliedEntryToAdjust(true);            InsertApplEntry(              NewItemLedgEntry."Entry No.", NewItemLedgEntry."Entry No.",              OldItemLedgEntry."Entry No.", 0, NewItemLedgEntry."Posting Date",              -OldItemLedgEntry.Quantity, false);        end;        OnAfterUndoQuantityPosting(NewItemLedgEntry, ItemJnlLine);    end;    /// <summary>    /// Undoes the value entry posting of an item ledger entry with a job number.    /// </summary>    /// <param name="OldItemLedgEntryNo">Inbound item ledger entry number.</param>    /// <param name="NewItemLedgEntryNo">Outbound item ledger entry number.</param>    procedure UndoValuePostingWithJob(OldItemLedgEntryNo: Integer; NewItemLedgEntryNo: Integer)    var        OldItemLedgEntry: Record "Item Ledger Entry";        NewItemLedgEntry: Record "Item Ledger Entry";        OldValueEntry: Record "Value Entry";        NewValueEntry: Record "Value Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUndoValuePostingWithJob(OldItemLedgEntryNo, NewItemLedgEntryNo, IsHandled);        if IsHandled then            exit;        OldItemLedgEntry.Get(OldItemLedgEntryNo);        NewItemLedgEntry.Get(NewItemLedgEntryNo);        InitValueEntryNo();        if OldItemLedgEntry."Invoiced Quantity" = 0 then begin            CalcILEExpectedAmount(OldValueEntry, OldItemLedgEntry."Entry No.");            InsertCorrValueEntry(              OldValueEntry, NewValueEntry, OldItemLedgEntry, OldValueEntry."Document Line No.", 1,              0, OldItemLedgEntry.Quantity);            CalcILEExpectedAmount(OldValueEntry, NewItemLedgEntry."Entry No.");            InsertCorrValueEntry(              OldValueEntry, NewValueEntry, NewItemLedgEntry, NewItemLedgEntry."Document Line No.", 1,              0, NewItemLedgEntry.Quantity);        end else            InsertCorrValueEntry(              OldValueEntry, NewValueEntry, NewItemLedgEntry, NewItemLedgEntry."Document Line No.", -1,              NewItemLedgEntry.Quantity, NewItemLedgEntry.Quantity);        UpdateOldItemLedgEntry(OldItemLedgEntry, NewItemLedgEntry."Posting Date");        UpdateOldItemLedgEntry(NewItemLedgEntry, NewItemLedgEntry."Posting Date");        UpdateItemApplnEntry(OldItemLedgEntry."Entry No.", NewItemLedgEntry."Posting Date");        NewItemLedgEntry.Modify();        UpdateAdjmtProperties(NewValueEntry, NewItemLedgEntry."Posting Date");        if NewItemLedgEntry.Positive then            UpdateOrigAppliedFromEntry(OldItemLedgEntry."Entry No.");    end;    local procedure InitCorrItemLedgEntry(var OldItemLedgEntry: Record "Item Ledger Entry"; var NewItemLedgEntry: Record "Item Ledger Entry")    var        EntriesExist: Boolean;    begin        if OldItemLedgEntry."Entry Type" = OldItemLedgEntry."Entry Type"::Sale then            if (OldItemLedgEntry."Serial No." <> '') and (OldItemLedgEntry."Serial No." = ItemJnlLine."Serial No.") and                ((-OldItemLedgEntry.Quantity) > 0)            then                CheckItemSerialNoForCorrILE(ItemJnlLine);        ItemLedgEntryNo := GetNextItemLedgerEntryNo(ItemLedgEntryNo);        NewItemLedgEntry := OldItemLedgEntry;        ItemTrackingMgt.RetrieveAppliedExpirationDate(NewItemLedgEntry);        OnInitCorrItemLedgEntryOnAfterRetrieveAppliedExpirationDate(NewItemLedgEntry);        NewItemLedgEntry."Entry No." := ItemLedgEntryNo;        NewItemLedgEntry.Quantity := -OldItemLedgEntry.Quantity;        if (NewItemLedgEntry."Drop Shipment") and (NewItemLedgEntry."Document Type" = NewItemLedgEntry."Document Type"::"Sales Shipment") then            NewItemLedgEntry."Remaining Quantity" := 0        else            NewItemLedgEntry."Remaining Quantity" := -OldItemLedgEntry.Quantity;        if NewItemLedgEntry.Quantity > 0 then            NewItemLedgEntry."Shipped Qty. Not Returned" := 0        else            NewItemLedgEntry."Shipped Qty. Not Returned" := NewItemLedgEntry.Quantity;        NewItemLedgEntry."Invoiced Quantity" := NewItemLedgEntry.Quantity;        NewItemLedgEntry.Positive := NewItemLedgEntry."Remaining Quantity" > 0;        if (NewItemLedgEntry."Drop Shipment") and (NewItemLedgEntry."Document Type" = NewItemLedgEntry."Document Type"::"Sales Shipment") then            NewItemLedgEntry.Open := false        else            NewItemLedgEntry.Open := NewItemLedgEntry."Remaining Quantity" <> 0;        NewItemLedgEntry."Completely Invoiced" := true;        NewItemLedgEntry."Last Invoice Date" := NewItemLedgEntry."Posting Date";        NewItemLedgEntry.Correction := true;        NewItemLedgEntry."Document Line No." := ItemJnlLine."Document Line No.";        if OldItemLedgEntry.Positive then            NewItemLedgEntry."Applies-to Entry" := OldItemLedgEntry."Entry No."        else            NewItemLedgEntry."Applies-to Entry" := 0;        InsertItemReg(NewItemLedgEntry."Entry No.", 0, 0, 0);        NewItemLedgEntry."Item Register No." := ItemReg."No.";        OnBeforeInsertCorrItemLedgEntry(NewItemLedgEntry, OldItemLedgEntry, ItemJnlLine);        NewItemLedgEntry.Insert(true);        OnAfterInsertCorrItemLedgEntry(NewItemLedgEntry, ItemJnlLine, OldItemLedgEntry);        if NewItemLedgEntry."Item Tracking" <> NewItemLedgEntry."Item Tracking"::None then            ItemTrackingMgt.ExistingExpirationDate(NewItemLedgEntry, true, EntriesExist);        OnAfterInitCorrItemLedgEntry(NewItemLedgEntry, EntriesExist);    end;    local procedure UpdateOldItemLedgEntry(var OldItemLedgEntry: Record "Item Ledger Entry"; LastInvoiceDate: Date)    begin        OldItemLedgEntry."Completely Invoiced" := true;        OldItemLedgEntry."Last Invoice Date" := LastInvoiceDate;        OldItemLedgEntry."Invoiced Quantity" := OldItemLedgEntry.Quantity;        OldItemLedgEntry."Shipped Qty. Not Returned" := 0;        OnBeforeOldItemLedgEntryModify(OldItemLedgEntry);        OldItemLedgEntry.Modify();    end;    local procedure InsertCorrValueEntry(OldValueEntry: Record "Value Entry"; var NewValueEntry: Record "Value Entry"; ItemLedgEntry: Record "Item Ledger Entry"; DocumentLineNo: Integer; Sign: Integer; QtyToShip: Decimal; QtyToInvoice: Decimal)    var        xValueEntryNo: Integer;        ShouldInsertValueEntry: Boolean;    begin        ValueEntryNo := GetNextValueEntryNo(ValueEntryNo);        NewValueEntry := OldValueEntry;        xValueEntryNo := ValueEntryNo;        OnInsertCorrValueEntryOnAfterAssignNewValueEntry(GlobalItemLedgEntry, OldValueEntry, NewValueEntry, ItemJnlLine, ItemLedgEntry, ValueEntryNo);        if (ValueEntryNo <> xValueEntryNo) and not InvtSetup.UseLegacyPosting() then begin            ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");            ValueEntryNo := GetNextValueEntryNo(ValueEntryNo);        end;        NewValueEntry."Entry No." := ValueEntryNo;        NewValueEntry."Item Ledger Entry No." := ItemLedgEntry."Entry No.";        NewValueEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewValueEntry."User ID"));        NewValueEntry."Valued Quantity" := Sign * OldValueEntry."Valued Quantity";        NewValueEntry."Document Line No." := DocumentLineNo;        NewValueEntry."Item Ledger Entry Quantity" := QtyToShip;        NewValueEntry."Invoiced Quantity" := QtyToInvoice;        NewValueEntry."Expected Cost" := QtyToInvoice = 0;        if not NewValueEntry."Expected Cost" then begin            NewValueEntry."Cost Amount (Expected)" := -Sign * OldValueEntry."Cost Amount (Expected)";            NewValueEntry."Cost Amount (Expected) (ACY)" := -Sign * OldValueEntry."Cost Amount (Expected) (ACY)";            if QtyToShip = 0 then begin                NewValueEntry."Cost Amount (Actual)" := Sign * OldValueEntry."Cost Amount (Expected)";                NewValueEntry."Cost Amount (Actual) (ACY)" := Sign * OldValueEntry."Cost Amount (Expected) (ACY)";            end else begin                NewValueEntry."Cost Amount (Actual)" := -NewValueEntry."Cost Amount (Actual)";                NewValueEntry."Cost Amount (Actual) (ACY)" := -NewValueEntry."Cost Amount (Actual) (ACY)";            end;            NewValueEntry."Purchase Amount (Expected)" := -Sign * OldValueEntry."Purchase Amount (Expected)";            NewValueEntry."Sales Amount (Expected)" := -Sign * OldValueEntry."Sales Amount (Expected)";        end else begin            NewValueEntry."Cost Amount (Expected)" := -OldValueEntry."Cost Amount (Expected)";            NewValueEntry."Cost Amount (Expected) (ACY)" := -OldValueEntry."Cost Amount (Expected) (ACY)";            NewValueEntry."Cost Amount (Actual)" := 0;            NewValueEntry."Cost Amount (Actual) (ACY)" := 0;            NewValueEntry."Sales Amount (Expected)" := -OldValueEntry."Sales Amount (Expected)";            NewValueEntry."Purchase Amount (Expected)" := -OldValueEntry."Purchase Amount (Expected)";        end;        NewValueEntry."Purchase Amount (Actual)" := 0;        NewValueEntry."Sales Amount (Actual)" := 0;        NewValueEntry."Cost Amount (Non-Invtbl.)" := Sign * OldValueEntry."Cost Amount (Non-Invtbl.)";        NewValueEntry."Cost Amount (Non-Invtbl.)(ACY)" := Sign * OldValueEntry."Cost Amount (Non-Invtbl.)(ACY)";        NewValueEntry."Cost Posted to G/L" := 0;        NewValueEntry."Cost Posted to G/L (ACY)" := 0;        NewValueEntry."Expected Cost Posted to G/L" := 0;        NewValueEntry."Exp. Cost Posted to G/L (ACY)" := 0;        xValueEntryNo := ValueEntryNo;        OnBeforeInsertCorrValueEntry(NewValueEntry, OldValueEntry, ItemJnlLine, Sign, CalledFromAdjustment, ItemLedgEntry, ValueEntryNo, InventoryPostingToGL);        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");        PostInventoryToGL(NewValueEntry);        InsertItemReg(0, 0, NewValueEntry."Entry No.", 0);        NewValueEntry."Item Register No." := ItemReg."No.";        ShouldInsertValueEntry := true;        OnInsertCorrValueEntryOnBeforeInsert(NewValueEntry, ItemLedgEntry, ShouldInsertValueEntry, ItemJnlLine);        if not ShouldInsertValueEntry then            exit;        NewValueEntry.Insert(true);        xValueEntryNo := ValueEntryNo;        OnAfterInsertCorrValueEntry(NewValueEntry, ItemJnlLine, ItemLedgEntry, ValueEntryNo);        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");        ItemApplnEntry.SetOutboundsNotUpdated(ItemLedgEntry);        UpdateAdjmtProperties(NewValueEntry, ItemLedgEntry."Posting Date");        InsertPostValueEntryToGL(NewValueEntry);    end;    local procedure UpdateOrigAppliedFromEntry(OldItemLedgEntryNo: Integer)    var        ItemApplEntry: Record "Item Application Entry";        ItemLedgEntry: Record "Item Ledger Entry";    begin        ItemApplEntry.SetCurrentKey("Outbound Item Entry No.", "Item Ledger Entry No.");        ItemApplEntry.SetRange("Outbound Item Entry No.", OldItemLedgEntryNo);        ItemApplEntry.SetFilter("Item Ledger Entry No.", '<>%1', OldItemLedgEntryNo);        if ItemApplEntry.FindSet() then            repeat                if ItemLedgEntry.Get(ItemApplEntry."Inbound Item Entry No.") and                   not ItemLedgEntry."Applied Entry to Adjust"                then begin                    ItemLedgEntry."Applied Entry to Adjust" := true;                    ItemLedgEntry.Modify();                end;                OnUpdateOrigAppliedFromEntryOnItemApplEntryLoop(ItemLedgEntry, ItemApplEntry);            until ItemApplEntry.Next() = 0;    end;    local procedure GetItem(ItemNo: Code[20]; Unconditionally: Boolean): Boolean    var        HasGotItem: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetItem(Item, ItemNo, Unconditionally, HasGotItem, IsHandled);        if IsHandled then            exit(HasGotItem);        Item.ReadIsolation(IsolationLevel::ReadUncommitted);        if not Unconditionally then            exit(Item.Get(ItemNo))        else            Item.Get(ItemNo);        exit(true);    end;    local procedure GetItemVariant(ItemNo: Code[20]; VariantCode: Code[10]; Unconditionally: Boolean): Boolean    var        ReturnValue: Boolean;        IsHandled: Boolean;    begin        OnBeforeGetItemVariant(ItemVariant, ItemNo, VariantCode, Unconditionally, ReturnValue, IsHandled);        if IsHandled then            exit(ReturnValue);        if VariantCode = '' then begin            Clear(ItemVariant);            exit(false);        end;        if not Unconditionally then            exit(ItemVariant.Get(ItemNo, VariantCode))        else            ItemVariant.Get(ItemNo, VariantCode);        exit(true);    end;    local procedure CheckItemAndItemVariant(ItemNo: Code[20]; VariantCode: Code[10])    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckItemAndItemVariant(ItemNo, VariantCode, Item, ItemVariant, IsHandled);        if IsHandled then            exit;        if GetItem(ItemNo, false) then begin            if not CalledFromAdjustment then                Item.TestField(Blocked, false);            OnCheckItemOnAfterGetItem(Item, ItemJnlLine, CalledFromAdjustment);            if GetItemVariant(ItemNo, VariantCode, false) then begin                if not CalledFromAdjustment then                    ItemVariant.TestField(Blocked, false);                OnCheckItemVariantOnAfterGetItemVariant(ItemVariant, ItemJnlLine, CalledFromAdjustment);            end else                ItemVariant.Init();        end else            Item.Init();        OnAfterCheckItemAndVariant(ItemJnlLine, CalledFromAdjustment);    end;    /// <summary>    /// Checks the tracking information of an item journal. If serial, lot or package numbers are required but are missing, an error is thrown.    /// </summary>    /// <remarks>    /// If the journal line is a transfer, it also checks for new serial, lot and package numbers to be assigned during the posting.    /// </remarks>#if not CLEAN27    [Obsolete('Replaced by same procedure with parameters ItemJnlLine', '27.0')]    procedure CheckItemTracking()    begin        CheckItemTracking(ItemJnlLine);    end;#endif    procedure CheckItemTracking(var ItemJnlLine2: Record "Item Journal Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckItemTracking(ItemJnlLine2, GlobalItemTrackingSetup, IsHandled, TempTrackingSpecification);        if IsHandled then            exit;        if GlobalItemTrackingSetup."Serial No. Required" and (ItemJnlLine2."Serial No." = '') then            Error(GetTextStringWithLineNo(SerialNoRequiredErr, ItemJnlLine2."Item No.", ItemJnlLine2."Line No."));        if GlobalItemTrackingSetup."Lot No. Required" and (ItemJnlLine2."Lot No." = '') then            Error(GetTextStringWithLineNo(LotNoRequiredErr, ItemJnlLine2."Item No.", ItemJnlLine2."Line No."));        IsHandled := false;        OnCheckItemTrackingOnAfterCheckRequiredTrackingNos(ItemJnlLine2, GlobalItemTrackingSetup, IsHandled);        if not IsHandled then            if ItemJnlLine2."Entry Type" = ItemJnlLine2."Entry Type"::Transfer then                ItemJnlLine2.CheckNewTrackingIfRequired(GlobalItemTrackingSetup);        OnAfterCheckItemTracking(ItemJnlLine2, GlobalItemTrackingSetup, GlobalItemTrackingCode);    end;    local procedure CheckItemTrackingInformation(var ItemJnlLine2: Record "Item Journal Line"; var TrackingSpecification: Record "Tracking Specification"; SignFactor: Decimal; ItemTrackingCode: Record "Item Tracking Code"; ItemTrackingSetup: Record "Item Tracking Setup")    var        SerialNoInfo: Record "Serial No. Information";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckItemTrackingInformation(ItemJnlLine2, TrackingSpecification, ItemTrackingSetup, SignFactor, ItemTrackingCode, IsHandled, GlobalItemTrackingCode);        if IsHandled then            exit;        if ItemTrackingCode."Create SN Info on Posting" then            ItemTrackingMgt.CreateSerialNoInformation(TrackingSpecification);        IsHandled := false;        OnCheckItemTrackingInformationOnBeforeTestFields(ItemTrackingSetup, TrackingSpecification, ItemJnlLine2, IsHandled);        if not IsHandled then            if ItemTrackingSetup."Serial No. Info Required" then begin                SerialNoInfo.Get(ItemJnlLine2."Item No.", ItemJnlLine2."Variant Code", TrackingSpecification."Serial No.");                SerialNoInfo.TestField(Blocked, false);                if TrackingSpecification."New Serial No." <> '' then begin                    SerialNoInfo.Get(ItemJnlLine2."Item No.", ItemJnlLine2."Variant Code", TrackingSpecification."New Serial No.");                    SerialNoInfo.TestField(Blocked, false);                end;            end else begin                if SerialNoInfo.Get(ItemJnlLine2."Item No.", ItemJnlLine2."Variant Code", TrackingSpecification."Serial No.") then                    SerialNoInfo.TestField(Blocked, false);                if TrackingSpecification."New Serial No." <> '' then                    if SerialNoInfo.Get(ItemJnlLine2."Item No.", ItemJnlLine2."Variant Code", TrackingSpecification."New Serial No.") then                        SerialNoInfo.TestField(Blocked, false);            end;        if ItemTrackingCode."Create Lot No. Info on posting" then            ItemTrackingMgt.CreateLotNoInformation(TrackingSpecification);        CheckLotNoInfoNotBlocked(ItemTrackingSetup, ItemJnlLine2, TrackingSpecification);        OnAfterCheckItemTrackingInformation(ItemJnlLine2, TrackingSpecification, ItemTrackingSetup, Item);    end;    local procedure CheckLotNoInfoNotBlocked(ItemTrackingSetup: Record "Item Tracking Setup"; var ItemJnlLine2: Record "Item Journal Line"; var TrackingSpecification: Record "Tracking Specification")    var        LotNoInfo: Record "Lot No. Information";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckLotNoInfoNotBlocked(ItemJnlLine2, IsHandled, ItemTrackingSetup, TrackingSpecification);        if IsHandled then            exit;        if ItemTrackingSetup."Lot No. Info Required" then begin            LotNoInfo.Get(ItemJnlLine2."Item No.", ItemJnlLine2."Variant Code", TrackingSpecification."Lot No.");            LotNoInfo.TestField(Blocked, false);            if TrackingSpecification."New Lot No." <> '' then begin                LotNoInfo.Get(ItemJnlLine2."Item No.", ItemJnlLine2."Variant Code", TrackingSpecification."New Lot No.");                LotNoInfo.TestField(Blocked, false);            end;        end else begin            if LotNoInfo.Get(ItemJnlLine2."Item No.", ItemJnlLine2."Variant Code", TrackingSpecification."Lot No.") then                LotNoInfo.TestField(Blocked, false);            if TrackingSpecification."New Lot No." <> '' then                if LotNoInfo.Get(ItemJnlLine2."Item No.", ItemJnlLine2."Variant Code", TrackingSpecification."New Lot No.") then                    LotNoInfo.TestField(Blocked, false);        end;    end;    local procedure CheckItemTrackingIsEmpty(ItemJnlLine: Record "Item Journal Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckItemTrackingIsEmpty(ItemJnlLine, IsHandled);        if IsHandled then            exit;        ItemJnlLine.CheckTrackingIsEmpty();        ItemJnlLine.CheckNewTrackingIsEmpty();    end;    local procedure CheckItemSerialNo(ItemJnlLine: Record "Item Journal Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckSerialNo(ItemJnlLine, IsHandled, SkipSerialNoQtyValidation);        if IsHandled then            exit;        if SkipSerialNoQtyValidation then            exit;        if ItemJnlLine."Entry Type" = ItemJnlLine."Entry Type"::Transfer then begin            if ItemTrackingMgt.FindInInventory(ItemJnlLine."Item No.", ItemJnlLine."Variant Code", ItemJnlLine."New Serial No.") then                Error(Text014, ItemJnlLine."New Serial No.")        end else            if ItemTrackingMgt.FindInInventory(ItemJnlLine."Item No.", ItemJnlLine."Variant Code", ItemJnlLine."Serial No.") then                Error(Text014, ItemJnlLine."Serial No.");    end;    local procedure CheckItemCorrection(ItemLedgerEntry: Record "Item Ledger Entry")    var        RaiseError: Boolean;    begin        RaiseError := ItemLedgerEntry.Correction;        OnBeforeCheckItemCorrection(ItemLedgerEntry, RaiseError);        if RaiseError then            Error(CannotUnapplyCorrEntryErr);    end;    local procedure InsertTempTrkgSpecification(FreeEntryNo: Integer)    var        TempTrackingSpecification2: Record "Tracking Specification" temporary;    begin        if not TempTrackingSpecification.Insert() then begin            TempTrackingSpecification2 := TempTrackingSpecification;            TempTrackingSpecification.Get(TempTrackingSpecification2."Item Ledger Entry No.");            TempTrackingSpecification.Delete();            TempTrackingSpecification."Entry No." := FreeEntryNo;            TempTrackingSpecification.Insert();            TempTrackingSpecification := TempTrackingSpecification2;            TempTrackingSpecification.Insert();        end;    end;    local procedure IsNotInternalWhseMovement(ItemJnlLine: Record "Item Journal Line") Result: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeIsNotInternalWhseMovement(ItemJnlLine, Result, IsHandled);        if IsHandled then            exit(Result);        exit(ItemJnlLine.IsNotInternalWhseMovement());    end;    /// <summary>    /// Sets the value of the global flag CalledFromInvtPutawayPick.    /// </summary>    /// <param name="NewCalledFromInvtPutawayPick">The new value to set.</param>    procedure SetCalledFromInvtPutawayPick(NewCalledFromInvtPutawayPick: Boolean)    begin        CalledFromInvtPutawayPick := NewCalledFromInvtPutawayPick;    end;    /// <summary>    /// Sets the values of the global flags CalledFromAdjustment and PostToGL.    /// </summary>    /// <param name="NewCalledFromAdjustment">The new value to set.</param>    /// <param name="NewPostToGL">The new value to set.</param>    procedure SetCalledFromAdjustment(NewCalledFromAdjustment: Boolean; NewPostToGL: Boolean)    begin        OnBeforeSetCalledFromAdjustment(CalledFromAdjustment);        CalledFromAdjustment := NewCalledFromAdjustment;        PostToGL := NewPostToGL;    end;    /// <summary>    /// Resets the transaction-scoped state of the downstream G/L posting codeunits    /// (Codeunit "Inventory Posting To G/L" -> Codeunit "Gen. Jnl.-Post Line") so the    /// next G/L posting call re-takes the G/L Entry table lock and re-reads the last    /// entry number from disk. Must be called by any caller that issues an explicit    /// Commit() while keeping a long-lived reference to this codeunit (for example    /// Codeunit 5895 "Inventory Adjustment".CheckAndCommit). The configuration set via    /// SetCalledFromAdjustment / SetCalledFromInvtPutawayPick / etc. is preserved.    /// </summary>    procedure ResetGLPostingState()    begin        InventoryPostingToGL.ResetGLPostingState();    end;    internal procedure GetPostToGL(): Boolean    begin        exit(PostToGL);    end;#if not CLEAN27    /// <summary>    /// Determines if the next operation number exists on the provided production order routing line.    /// </summary>    /// <param name="ProdOrderRtngLine">Production order routing line to check.</param>    /// <returns>True if next operation number exists, otherwise false.</returns>    [Obsolete('Moved to table ProdOrderRoutingLine', '27.0')]    procedure NextOperationExist(var ProdOrderRtngLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"): Boolean    begin        OnBeforeNextOperationExist(ProdOrderRtngLine);        exit(ProdOrderRtngLine."Next Operation No." <> '');    end;#endif    local procedure UpdateAdjmtProperties(ValueEntry: Record "Value Entry"; OriginalPostingDate: Date)    begin        SetAdjmtProperties(            ValueEntry."Item No.", ValueEntry."Item Ledger Entry Type", ValueEntry.Adjustment,            ValueEntry."Order Type", ValueEntry."Order No.", ValueEntry."Order Line No.", OriginalPostingDate, ValueEntry."Valuation Date");        OnAfterUpdateAdjmtProp(ValueEntry, OriginalPostingDate);    end;    local procedure SetAdjmtProperties(ItemNo: Code[20]; ItemLedgEntryType: Enum "Item Ledger Entry Type"; Adjustment: Boolean; OrderType: Enum "Inventory Order Type"; OrderNo: Code[20]; OrderLineNo: Integer; OriginalPostingDate: Date; ValuationDate: Date)    begin        SetItemAdjmtProperties(ItemNo, ItemLedgEntryType, Adjustment, OriginalPostingDate, ValuationDate);        SetOrderAdjmtProperties(ItemLedgEntryType, OrderType, OrderNo, OrderLineNo, OriginalPostingDate, ValuationDate);    end;    local procedure SetItemAdjmtProperties(ItemNo: Code[20]; ItemLedgEntryType: Enum "Item Ledger Entry Type"; Adjustment: Boolean; OriginalPostingDate: Date; ValuationDate: Date)    var        Item2: Record Item;        ValueEntry: Record "Value Entry";        ModifyItem: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetItemAdjmtProperties(ItemNo, ItemLedgEntryType, Adjustment, OriginalPostingDate, ValuationDate, IsHandled);        if IsHandled then            exit;        if ItemLedgEntryType = ValueEntry."Item Ledger Entry Type"::" " then            exit;        if Adjustment then            if not (ItemLedgEntryType in [ValueEntry."Item Ledger Entry Type"::Output,                                          ValueEntry."Item Ledger Entry Type"::"Assembly Output"])            then                exit;        if Item2.Get(ItemNo) and (Item2."Allow Online Adjustment" or Item2."Cost is Adjusted") and (Item2.Type = Item2.Type::Inventory) then begin            Item2.LockTable();            if Item2."Cost is Adjusted" then begin                Item2."Cost is Adjusted" := false;                ModifyItem := true;            end;            if Item2."Allow Online Adjustment" then begin                if Item2."Costing Method" = Item2."Costing Method"::Average then                    Item2."Allow Online Adjustment" := AllowAdjmtOnPosting(ValuationDate)                else                    Item2."Allow Online Adjustment" := AllowAdjmtOnPosting(OriginalPostingDate);                ModifyItem := ModifyItem or not Item2."Allow Online Adjustment";            end;            OnSetItemAdjmtPropertiesOnBeforeCheckModifyItem(Item2, ModifyItem);            if ModifyItem then                Item2.Modify();        end;    end;    local procedure SetOrderAdjmtProperties(ItemLedgEntryType: Enum "Item Ledger Entry Type"; OrderType: Enum "Inventory Order Type"; OrderNo: Code[20]; OrderLineNo: Integer; OriginalPostingDate: Date; ValuationDate: Date)    var        ValueEntry: Record "Value Entry";        InventoryAdjmtEntryOrder: Record "Inventory Adjmt. Entry (Order)";        AssemblyHeader: Record "Assembly Header";        ModifyOrderAdjmt: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetOrderAdjmtProperties(            ItemLedgEntryType.AsInteger(), OrderType.AsInteger(), OrderNo, OrderLineNo, OriginalPostingDate, ValuationDate, IsHandled, ItemJnlLine);        if IsHandled then            exit;        if not (OrderType in [ValueEntry."Order Type"::Production,                              ValueEntry."Order Type"::Assembly])        then            exit;        if ItemLedgEntryType in [ValueEntry."Item Ledger Entry Type"::Output,                                 ValueEntry."Item Ledger Entry Type"::"Assembly Output"]        then            exit;        if not InventoryAdjmtEntryOrder.Get(OrderType, OrderNo, OrderLineNo) then            case OrderType of                InventoryAdjmtEntryOrder."Order Type"::Production:                    begin                        OnSetOrderAdjmtPropertiesForProduction(InventoryAdjmtEntryOrder, OrderNo, OrderLineNo);                        SetOrderAdjmtProperties(ItemLedgEntryType, OrderType, OrderNo, OrderLineNo, OriginalPostingDate, ValuationDate);                    end;                InventoryAdjmtEntryOrder."Order Type"::Assembly:                    begin                        if OrderLineNo = 0 then begin                            AssemblyHeader.SetLoadFields("Item No.");                            AssemblyHeader.Get(AssemblyHeader."Document Type"::Order, OrderNo);                            InventoryAdjmtEntryOrder.SetAsmOrder(AssemblyHeader);                        end;                        SetOrderAdjmtProperties(ItemLedgEntryType, OrderType, OrderNo, 0, OriginalPostingDate, ValuationDate);                    end;            end        else            if InventoryAdjmtEntryOrder."Allow Online Adjustment" or InventoryAdjmtEntryOrder."Cost is Adjusted" then begin                InventoryAdjmtEntryOrder.LockTable();                IsHandled := false;                OnSetOrderAdjmtPropertiesOnBeforeSetCostIsAdjusted(InventoryAdjmtEntryOrder, ModifyOrderAdjmt, IsHandled, OriginalPostingDate);                if not IsHandled then                    if InventoryAdjmtEntryOrder."Cost is Adjusted" then begin                        InventoryAdjmtEntryOrder."Cost is Adjusted" := false;                        ModifyOrderAdjmt := true;                    end;                IsHandled := false;                OnSetOrderAdjmtPropertiesOnBeforeSetAllowOnlineAdjustment(InventoryAdjmtEntryOrder, ModifyOrderAdjmt, IsHandled, OriginalPostingDate);                if not IsHandled then                    if InventoryAdjmtEntryOrder."Allow Online Adjustment" then begin                        InventoryAdjmtEntryOrder."Allow Online Adjustment" := AllowAdjmtOnPosting(OriginalPostingDate);                        ModifyOrderAdjmt := ModifyOrderAdjmt or not InventoryAdjmtEntryOrder."Allow Online Adjustment";                    end;                if ModifyOrderAdjmt then                    InventoryAdjmtEntryOrder.Modify();            end;    end;    /// <summary>    /// Determines if an adjustment is allowed on a given posting date based on the automatic cost adjustment setting     /// in the inventory setup.    /// </summary>    /// <param name="TheDate">The date to check.</param>    /// <returns>True if adjustment is allowed, otherwise false.</returns>    procedure AllowAdjmtOnPosting(TheDate: Date): Boolean    begin        GetInvtSetup();        case InvtSetup."Automatic Cost Adjustment" of            InvtSetup."Automatic Cost Adjustment"::Never:                exit(false);            InvtSetup."Automatic Cost Adjustment"::Day:                exit(TheDate >= CalcDate('<-1D>', WorkDate()));            InvtSetup."Automatic Cost Adjustment"::Week:                exit(TheDate >= CalcDate('<-1W>', WorkDate()));            InvtSetup."Automatic Cost Adjustment"::Month:                exit(TheDate >= CalcDate('<-1M>', WorkDate()));            InvtSetup."Automatic Cost Adjustment"::Quarter:                exit(TheDate >= CalcDate('<-1Q>', WorkDate()));            InvtSetup."Automatic Cost Adjustment"::Year:                exit(TheDate >= CalcDate('<-1Y>', WorkDate()));            else                exit(true);        end;    end;    local procedure InsertBalanceExpCostRevEntry(ValueEntry: Record "Value Entry")    var        ValueEntry2: Record "Value Entry";        ValueEntry3: Record "Value Entry";        RevExpCostToBalance: Decimal;        RevExpCostToBalanceACY: Decimal;        xValueEntryNo: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        xValueEntryNo := ValueEntryNo;        OnBeforeInsertBalanceExpCostRevEntry(GlobalItemLedgEntry, ValueEntry, ValueEntryNo, GLSetup, Currency, GLSetupRead, IsHandled);        ValidateSequenceNo(ValueEntryNo, xValueEntryNo, Database::"Value Entry");        if IsHandled then            exit;        if GlobalItemLedgEntry.Quantity - (GlobalItemLedgEntry."Invoiced Quantity" - ValueEntry."Invoiced Quantity") = 0 then            exit;        ValueEntry2.SetCurrentKey("Item Ledger Entry No.", "Entry Type");        ValueEntry2.SetRange("Item Ledger Entry No.", ValueEntry."Item Ledger Entry No.");        ValueEntry2.SetRange("Entry Type", ValueEntry2."Entry Type"::Revaluation);        ValueEntry2.SetRange("Applies-to Entry", 0);        if ValueEntry2.FindSet() then            repeat                CalcRevExpCostToBalance(ValueEntry2, ValueEntry."Invoiced Quantity", RevExpCostToBalance, RevExpCostToBalanceACY);                if (RevExpCostToBalance <> 0) or (RevExpCostToBalanceACY <> 0) then begin                    ValueEntryNo := GetNextValueEntryNo(ValueEntryNo);                    ValueEntry3 := ValueEntry;                    ValueEntry3."Entry No." := ValueEntryNo;                    ValueEntry3."Item Charge No." := '';                    ValueEntry3."Entry Type" := ValueEntry."Entry Type"::Revaluation;                    ValueEntry3."Valuation Date" := ValueEntry2."Valuation Date";                    ValueEntry3.Description := '';                    ValueEntry3."Applies-to Entry" := ValueEntry2."Entry No.";                    ValueEntry3."Cost Amount (Expected)" := RevExpCostToBalance;                    ValueEntry3."Cost Amount (Expected) (ACY)" := RevExpCostToBalanceACY;                    ValueEntry3."Valued Quantity" := ValueEntry2."Valued Quantity";                    ValueEntry3."Cost per Unit" := CalcCostPerUnit(RevExpCostToBalance, ValueEntry."Valued Quantity", false);                    ValueEntry3."Cost per Unit (ACY)" := CalcCostPerUnit(RevExpCostToBalanceACY, ValueEntry."Valued Quantity", true);                    ValueEntry3."Cost Posted to G/L" := 0;                    ValueEntry3."Cost Posted to G/L (ACY)" := 0;                    ValueEntry3."Expected Cost Posted to G/L" := 0;                    ValueEntry3."Exp. Cost Posted to G/L (ACY)" := 0;                    ValueEntry3."Invoiced Quantity" := 0;                    ValueEntry3."Sales Amount (Actual)" := 0;                    ValueEntry3."Purchase Amount (Actual)" := 0;                    ValueEntry3."Discount Amount" := 0;                    ValueEntry3."Cost Amount (Actual)" := 0;                    ValueEntry3."Cost Amount (Actual) (ACY)" := 0;                    ValueEntry3."Sales Amount (Expected)" := 0;                    ValueEntry3."Purchase Amount (Expected)" := 0;                    InsertValueEntry(ValueEntry3, GlobalItemLedgEntry, false);                end;            until ValueEntry2.Next() = 0;    end;    local procedure IsBalanceExpectedCostFromRev(ItemJnlLine2: Record "Item Journal Line"): Boolean    begin        exit((Item."Costing Method" = Item."Costing Method"::Standard) and              (((ItemJnlLine2.Quantity = 0) and (ItemJnlLine2."Invoiced Quantity" <> 0)) or               (ItemJnlLine2.Adjustment and not GlobalValueEntry."Expected Cost")));    end;    local procedure CalcRevExpCostToBalance(ValueEntry: Record "Value Entry"; InvdQty: Decimal; var RevExpCostToBalance: Decimal; var RevExpCostToBalanceACY: Decimal)    var        ValueEntry2: Record "Value Entry";        OldExpectedQty: Decimal;    begin        RevExpCostToBalance := -ValueEntry."Cost Amount (Expected)";        RevExpCostToBalanceACY := -ValueEntry."Cost Amount (Expected) (ACY)";        OldExpectedQty := GlobalItemLedgEntry.Quantity;        ValueEntry2.SetCurrentKey("Item Ledger Entry No.", "Entry Type");        ValueEntry2.SetRange("Item Ledger Entry No.", ValueEntry."Item Ledger Entry No.");        if GlobalItemLedgEntry.Quantity <> GlobalItemLedgEntry."Invoiced Quantity" then begin            ValueEntry2.SetRange("Entry Type", ValueEntry2."Entry Type"::"Direct Cost");            if ValueEntry."Entry No." >= 0 then                ValueEntry2.SetFilter("Entry No.", '<%1', ValueEntry."Entry No.")            else                if not IsNullGuid(ValueEntry.SystemID) then                    ValueEntry2.SetFilter(SystemID, '<%1', ValueEntry.SystemID);  // Preview?            ValueEntry2.SetRange("Item Charge No.", '');            ValueEntry2.CalcSums("Invoiced Quantity");            OldExpectedQty -= ValueEntry2."Invoiced Quantity";            RevExpCostToBalance := Round(RevExpCostToBalance * InvdQty / OldExpectedQty, GLSetup."Amount Rounding Precision");            RevExpCostToBalanceACY := Round(RevExpCostToBalanceACY * InvdQty / OldExpectedQty, Currency."Amount Rounding Precision");        end else begin            ValueEntry2.SetRange("Entry Type", ValueEntry2."Entry Type"::Revaluation);            ValueEntry2.SetRange("Applies-to Entry", ValueEntry."Entry No.");            ValueEntry2.CalcSums("Cost Amount (Expected)", "Cost Amount (Expected) (ACY)");            RevExpCostToBalance -= ValueEntry2."Cost Amount (Expected)";            RevExpCostToBalanceACY -= ValueEntry2."Cost Amount (Expected) (ACY)";        end;    end;    local procedure IsInterimRevaluation() Result: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeIsInterimRevaluation(ItemJnlLine, Result, IsHandled);        if IsHandled then            exit(Result);        exit((ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::Revaluation) and (ItemJnlLine.Quantity <> 0));    end;    procedure InsertPostValueEntryToGL(ValueEntry: Record "Value Entry")    var        PostValueEntryToGL: Record "Post Value Entry to G/L";    begin        if IsPostToGL(ValueEntry) then begin            PostValueEntryToGL.Init();            PostValueEntryToGL."Value Entry No." := ValueEntry."Entry No.";            PostValueEntryToGL."Item No." := ValueEntry."Item No.";            PostValueEntryToGL."Posting Date" := ValueEntry."Posting Date";            OnInsertPostValueEntryToGLOnAfterTransferFields(PostValueEntryToGL, ValueEntry);            PostValueEntryToGL.Insert();        end;        OnAfterInsertPostValueEntryToGL(ValueEntry);    end;    local procedure IsPostToGL(ValueEntry: Record "Value Entry") Result: Boolean    begin        GetInvtSetup();        Result :=            ValueEntry.Inventoriable and not PostToGL and            (((not ValueEntry."Expected Cost") and ((ValueEntry."Cost Amount (Actual)" <> 0) or (ValueEntry."Cost Amount (Actual) (ACY)" <> 0))) or            (InvtSetup."Expected Cost Posting to G/L" and ((ValueEntry."Cost Amount (Expected)" <> 0) or (ValueEntry."Cost Amount (Expected) (ACY)" <> 0))));        OnAfterIsPostToGL(ValueEntry, Result, PostToGL);    end;    local procedure IsWarehouseReclassification(ItemJournalLine: Record "Item Journal Line"): Boolean    begin        exit(ItemJournalLine."Warehouse Adjustment" and (ItemJournalLine."Entry Type" = ItemJournalLine."Entry Type"::Transfer));    end;    local procedure IsNotValuedByAverageCost(CostItemLedgEntryNo: Integer): Boolean    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.SetCurrentKey("Item Ledger Entry No.");        ValueEntry.SetRange("Item Ledger Entry No.", CostItemLedgEntryNo);        ValueEntry.SetRange("Valued By Average Cost", true);        exit(ValueEntry.IsEmpty());    end;    local procedure MoveApplication(var ItemLedgerEntry: Record "Item Ledger Entry"; var OldItemLedgerEntry: Record "Item Ledger Entry"): Boolean    var        ItemApplicationEntry: Record "Item Application Entry";        Enough: Boolean;        FixedApplication: Boolean;        IsHandled: Boolean;    begin        OnBeforeMoveApplication(ItemLedgerEntry, OldItemLedgerEntry);        FixedApplication := false;        OldItemLedgerEntry.TestField(Positive, true);        IsHandled := false;        OnMoveApplicationOnBeforeRemainingQtyCheck(ItemLedgerEntry, OldItemLedgerEntry, IsHandled);        if not IsHandled then            if (OldItemLedgerEntry."Remaining Quantity" < Abs(ItemLedgerEntry.Quantity)) and               (OldItemLedgerEntry."Remaining Quantity" < OldItemLedgerEntry.Quantity)            then begin                Enough := false;                ItemApplicationEntry.Reset();                ItemApplicationEntry.SetCurrentKey("Inbound Item Entry No.");                ItemApplicationEntry.SetRange("Inbound Item Entry No.", ItemLedgerEntry."Applies-to Entry");                ItemApplicationEntry.SetFilter("Outbound Item Entry No.", '<>0');                if ItemApplicationEntry.FindSet() then                    repeat                        if not ItemApplicationEntry.Fixed() then begin                            UnApply(ItemApplicationEntry);                            OldItemLedgerEntry.Get(OldItemLedgerEntry."Entry No.");                            OldItemLedgerEntry.CalcReservedQuantity();                            Enough :=                              Abs(OldItemLedgerEntry."Remaining Quantity" - OldItemLedgerEntry."Reserved Quantity") >=                              Abs(ItemLedgerEntry."Remaining Quantity");                        end else                            FixedApplication := true;                    until (ItemApplicationEntry.Next() = 0) or Enough                else                    exit(false);                // no applications found that could be undone                OnAfterMoveApplication(ItemLedgerEntry, OldItemLedgerEntry, Enough);                if not Enough and FixedApplication then                    ShowFixedApplicationError();                exit(Enough);            end;        exit(true);    end;    local procedure CheckApplication(ItemLedgEntry: Record "Item Ledger Entry"; OldItemLedgEntry: Record "Item Ledger Entry")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckApplication(ItemLedgEntry, OldItemLedgEntry, IsHandled);        if IsHandled then            exit;        if SkipApplicationCheck then begin            SkipApplicationCheck := false;            exit;        end;        IsHandled := false;        OnCheckApplicationOnBeforeRemainingQtyError(OldItemLedgEntry, ItemLedgEntry, IsHandled);        if IsHandled then            exit;        if Abs(OldItemLedgEntry."Remaining Quantity" - OldItemLedgEntry."Reserved Quantity") <           Abs(ItemLedgEntry."Remaining Quantity" - ItemLedgEntry."Reserved Quantity")        then            OldItemLedgEntry.FieldError("Remaining Quantity", Text004)    end;    local procedure CheckApplFromInProduction(var GlobalItemLedgerEntry: Record "Item Ledger Entry"; AppliesFRomEntryNo: Integer)    var        OldItemLedgerEntry: Record "Item Ledger Entry";    begin        if AppliesFRomEntryNo = 0 then            exit;        if (GlobalItemLedgerEntry."Order Type" = GlobalItemLedgerEntry."Order Type"::Production) and (GlobalItemLedgerEntry."Order No." <> '') then begin            OldItemLedgerEntry.Get(AppliesFRomEntryNo);            if not AllowProdApplication(OldItemLedgerEntry, GlobalItemLedgEntry) then                Error(                  Text022,                  OldItemLedgerEntry."Entry Type",                  GlobalItemLedgerEntry."Entry Type",                  GlobalItemLedgerEntry."Item No.",                  GlobalItemLedgerEntry."Order No.");            if ItemApplnEntry.CheckIsCyclicalLoop(GlobalItemLedgerEntry, OldItemLedgerEntry) then                Error(                  Text022,                  OldItemLedgerEntry."Entry Type",                  GlobalItemLedgerEntry."Entry Type",                  GlobalItemLedgerEntry."Item No.",                  GlobalItemLedgerEntry."Order No.");        end;    end;    /// <summary>    /// Reapplies all touched item ledger entries with remaining quantity, and deletes them afterwards.    /// </summary>    /// <remarks>    /// Touched item ledger entries are entries that have been marked or identified in some way during the posting process.    /// </remarks>    procedure RedoApplications()    var        TouchedItemLedgEntry: Record "Item Ledger Entry";        DialogWindow: Dialog;        "Count": Integer;        t: Integer;        IsHandled: Boolean;        SkipDialog: Boolean;    begin        SkipDialog := false;        OnBeforeRedoApplications(SkipDialog);        TempTouchedItemLedgerEntries.SetCurrentKey("Item No.", Open, "Variant Code", Positive, "Location Code", "Posting Date", "Entry No.");        if TempTouchedItemLedgerEntries.Find('-') then begin            if not SkipDialog then                DialogWindow.Open(Text01 +                    '@1@@@@@@@@@@@@@@@@@@@@@@@');            Count := TempTouchedItemLedgerEntries.Count();            t := 0;            repeat                t := t + 1;                if not SkipDialog then                    DialogWindow.Update(1, Round(t * 10000 / Count, 1));                TouchedItemLedgEntry.Get(TempTouchedItemLedgerEntries."Entry No.");                IsHandled := false;                OnRedoApplicationsOnBeforeReApply(TouchedItemLedgEntry, IsHandled);                if not IsHandled then                    if TouchedItemLedgEntry."Remaining Quantity" <> 0 then begin                        ReApply(TouchedItemLedgEntry, 0);                        TouchedItemLedgEntry.Get(TempTouchedItemLedgerEntries."Entry No.");                    end;            until TempTouchedItemLedgerEntries.Next() = 0;            if AnyTouchedEntries() then                VerifyTouchedOnInventory();            TempTouchedItemLedgerEntries.DeleteAll();            DeleteTouchedEntries();            if not SkipDialog then                DialogWindow.Close();        end;    end;    local procedure UpdateValuedByAverageCost(CostItemLedgEntryNo: Integer; ValuedByAverage: Boolean)    var        ValueEntry: Record "Value Entry";    begin        if CostItemLedgEntryNo = 0 then            exit;        ValueEntry.SetCurrentKey("Item Ledger Entry No.");        ValueEntry.SetRange("Item Ledger Entry No.", CostItemLedgEntryNo);        ValueEntry.SetRange(Inventoriable, true);        ValueEntry.SetRange("Valued By Average Cost", not ValuedByAverage);        ValueEntry.ModifyAll("Valued By Average Cost", ValuedByAverage);    end;    /// <summary>    /// Performs an inventory cost adjustment based on the automatic cost adjustment setting in the inventory setup.    /// </summary>    procedure CostAdjust()    var        InvtSetup: Record "Inventory Setup";        InventoryPeriod: Record "Inventory Period";        InventoryAdjustmentHandler: Codeunit "Inventory Adjustment Handler";        Opendate: Date;    begin        InvtSetup.Get();        InventoryPeriod.IsValidDate(Opendate);        if InvtSetup."Automatic Cost Adjustment" <> InvtSetup."Automatic Cost Adjustment"::Never then begin            if Opendate <> 0D then                Opendate := CalcDate('<+1D>', Opendate);            InventoryAdjustmentHandler.MakeInventoryAdjustment(true, InvtSetup."Automatic Cost Posting");        end;    end;    /// <summary>    /// Marks an item ledger entry as touched by inserting it into a global buffer.    /// </summary>    /// <param name="EntryNo">Item ledger entry to mark.</param>    procedure TouchEntry(EntryNo: Integer)    var        TouchedItemLedgEntry: Record "Item Ledger Entry";    begin        TouchedItemLedgEntry.Get(EntryNo);        TempTouchedItemLedgerEntries := TouchedItemLedgEntry;        if not TempTouchedItemLedgerEntries.Insert() then;    end;    local procedure TouchItemEntryCost(var ItemLedgerEntry: Record "Item Ledger Entry"; IsAdjustment: Boolean)    var        ValueEntry: Record "Value Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTouchItemEntryCost(ItemLedgerEntry, ItemJnlLine, IsAdjustment, IsHandled);        if IsHandled then            exit;        ItemLedgerEntry."Applied Entry to Adjust" := true;        SetAdjmtProperties(          ItemLedgerEntry."Item No.", ItemLedgerEntry."Entry Type", IsAdjustment, ItemLedgerEntry."Order Type", ItemLedgerEntry."Order No.", ItemLedgerEntry."Order Line No.", ItemLedgerEntry."Posting Date", ItemLedgerEntry."Posting Date");        OnTouchItemEntryCostOnAfterAfterSetAdjmtProp(ItemLedgerEntry, IsAdjustment);        if not IsAdjustment then begin            EnsureValueEntryLoaded(ValueEntry, ItemLedgerEntry);            AvgCostEntryPointHandler.UpdateValuationDate(ValueEntry);        end;    end;    /// <summary>    /// Determines if there are any temporary touched item ledger entries on the global record set.    /// </summary>    /// <returns>True if touched entires exists, otherwise false.</returns>    procedure AnyTouchedEntries(): Boolean    begin        exit(TempTouchedItemLedgerEntries.Find('-'));    end;    local procedure GetMaxAppliedValuationdate(ItemLedgerEntry: Record "Item Ledger Entry"): Date    var        ToItemApplnEntry: Record "Item Application Entry";        FromItemledgEntryNo: Integer;        FromInbound: Boolean;        MaxDate: Date;        NewDate: Date;    begin        FromInbound := ItemLedgerEntry.Positive;        FromItemledgEntryNo := ItemLedgerEntry."Entry No.";        if FromInbound then begin            ToItemApplnEntry.SetCurrentKey("Inbound Item Entry No.", "Item Ledger Entry No.", "Outbound Item Entry No.");            ToItemApplnEntry.SetRange("Inbound Item Entry No.", FromItemledgEntryNo);            ToItemApplnEntry.SetFilter("Outbound Item Entry No.", '<>%1', 0);            ToItemApplnEntry.SetFilter(Quantity, '>%1', 0);        end else begin            ToItemApplnEntry.SetCurrentKey("Outbound Item Entry No.", "Item Ledger Entry No.");            ToItemApplnEntry.SetRange("Outbound Item Entry No.", FromItemledgEntryNo);            ToItemApplnEntry.SetFilter(Quantity, '<%1', 0);        end;        if ToItemApplnEntry.FindSet() then begin            MaxDate := 0D;            repeat                if FromInbound then                    ItemLedgerEntry.Get(ToItemApplnEntry."Outbound Item Entry No.")                else                    ItemLedgerEntry.Get(ToItemApplnEntry."Inbound Item Entry No.");                NewDate := GetMaxValuationDate(ItemLedgerEntry);                MaxDate := max(NewDate, MaxDate);            until ToItemApplnEntry.Next() = 0        end;        exit(MaxDate);    end;    local procedure "Max"(Date1: Date; Date2: Date): Date    begin        if Date1 > Date2 then            exit(Date1);        exit(Date2);    end;    /// <summary>    /// Sets the valuation date of all value entry records associated with a given item ledger entry no. to a given date.    /// </summary>    /// <remarks>    /// The date is modified if the valuation date is not equal to the posting date, or if it's less than the given date,     /// or if it's greater than the given date and the application is fixed.    /// </remarks>    /// <param name="ItemLedgerEntryNo">Item ledger entry no. to find value entries for.</param>    /// <param name="ValuationDate">Valuation date to set.</param>    /// <param name="FixedApplication">Indicates if it's a fixed application.</param>    procedure SetValuationDateAllValueEntrie(ItemLedgerEntryNo: Integer; ValuationDate: Date; FixedApplication: Boolean)    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.Reset();        ValueEntry.SetCurrentKey("Item Ledger Entry No.");        ValueEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntryNo);        if ValueEntry.FindSet() then            repeat                if (ValueEntry."Valuation Date" <> ValueEntry."Posting Date") or                   (ValueEntry."Valuation Date" < ValuationDate) or                   ((ValueEntry."Valuation Date" > ValuationDate) and FixedApplication)                then begin                    ValueEntry."Valuation Date" := ValuationDate;                    ValueEntry.Modify();                end;            until ValueEntry.Next() = 0;    end;    /// <summary>    /// Sets the value of the global flag IsServUndoConsumption.    /// </summary>    /// <param name="Value">The new value to set.</param>    procedure SetServUndoConsumption(Value: Boolean)    begin        IsServUndoConsumption := Value;    end;    /// <summary>    /// Sets the value of the global flag ProdOrderCompModified.    /// </summary>    /// <param name="ProdOrderCompIsModified">The new value to set.</param>    procedure SetProdOrderCompModified(ProdOrderCompIsModified: Boolean)    begin        ProdOrderCompModified := ProdOrderCompIsModified;    end;    /// <summary>    /// Updates the country/region on the new item ledger entry based on the new or existing item ledger entry's location.    /// </summary>    /// <param name="NewItemLedgEntry">Return value: New item ledger entry with updated coutnry/region code.</param>    /// <param name="ItemLedgEntry">Existing item ledger entry.</param>    procedure InsertCountryCode(var NewItemLedgEntry: Record "Item Ledger Entry"; ItemLedgEntry: Record "Item Ledger Entry")    begin        if ItemLedgEntry."Location Code" = '' then            exit;        if NewItemLedgEntry."Location Code" = '' then begin            Location.Get(ItemLedgEntry."Location Code");            NewItemLedgEntry."Country/Region Code" := Location."Country/Region Code";        end else begin            Location.Get(NewItemLedgEntry."Location Code");            if not Location."Use As In-Transit" then begin                Location.Get(ItemLedgEntry."Location Code");                if not Location."Use As In-Transit" then                    NewItemLedgEntry."Country/Region Code" := Location."Country/Region Code";            end;        end;    end;    local procedure ReservationPreventsApplication(ApplicationEntry: Integer; ItemNo: Code[20]; ReservationsEntry: Record "Item Ledger Entry")    var        ReservationEntries: Record "Reservation Entry";        ReservEngineMgt: Codeunit "Reservation Engine Mgt.";        ReserveItemLedgEntry: Codeunit "Item Ledger Entry-Reserve";    begin        ReservEngineMgt.InitFilterAndSortingLookupFor(ReservationEntries, true);        ReserveItemLedgEntry.FilterReservFor(ReservationEntries, ReservationsEntry);        if ReservationEntries.FindFirst() then;        Error(          Text029,          ReservationsEntry.FieldCaption("Applies-to Entry"),          ApplicationEntry,          Item.FieldCaption("No."),          ItemNo,          ReservEngineMgt.CreateForText(ReservationEntries));    end;    local procedure CorrectOutputValuationDate(ItemLedgerEntry: Record "Item Ledger Entry")    var        TempValueEntry: Record "Value Entry" temporary;        ValuationDate: Date;        ShouldExit: Boolean;    begin        OnCorrectOutputValuationDateOnCheckProduction(ItemLedgerEntry, TempValueEntry, ValuationDate, ShouldExit);        if ShouldExit then            exit;        UpdateOutputEntryAndChain(TempValueEntry, ValuationDate);    end;    local procedure UpdateOutputEntryAndChain(var TempValueEntry: Record "Value Entry" temporary; ValuationDate: Date)    var        ValueEntry: Record "Value Entry";        ItemLedgerEntryNo: Integer;    begin        TempValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type");        if TempValueEntry.Find('-') then            repeat                ValueEntry.Get(TempValueEntry."Entry No.");                if ValueEntry."Valuation Date" < ValuationDate then begin                    if ItemLedgerEntryNo <> TempValueEntry."Item Ledger Entry No." then begin                        ItemLedgerEntryNo := TempValueEntry."Item Ledger Entry No.";                        UpdateLinkedValuationDate(ValuationDate, ItemLedgerEntryNo, true);                    end;                    ValueEntry."Valuation Date" := ValuationDate;                    ValueEntry.Modify();                    if ValueEntry."Entry No." = DirCostValueEntry."Entry No." then                        DirCostValueEntry := ValueEntry;                end;            until TempValueEntry.Next() = 0;    end;    local procedure GetSourceNo(ItemJnlLine: Record "Item Journal Line") Result: Code[20]    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetSourceNo(ItemJnlLine, Result, IsHandled);        if IsHandled then            exit(Result);        if ItemJnlLine."Job No." = '' then            if ItemJnlLine."Invoice-to Source No." <> '' then                exit(ItemJnlLine."Invoice-to Source No.");        exit(ItemJnlLine."Source No.");    end;    local procedure PostAssemblyResourceConsump()    var        CapLedgEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry";        DirCostAmt: Decimal;        IndirCostAmt: Decimal;    begin        InsertCapLedgEntry(ItemJnlLine, CapLedgEntry, ItemJnlLine.Quantity, ItemJnlLine.Quantity);        CalcDirAndIndirCostAmts(DirCostAmt, IndirCostAmt, ItemJnlLine.Quantity, ItemJnlLine);        InsertCapValueEntry(ItemJnlLine, CapLedgEntry, ItemJnlLine."Value Entry Type"::"Direct Cost", ItemJnlLine.Quantity, ItemJnlLine.Quantity, DirCostAmt);        InsertCapValueEntry(ItemJnlLine, CapLedgEntry, ItemJnlLine."Value Entry Type"::"Indirect Cost", ItemJnlLine.Quantity, 0, IndirCostAmt);    end;    local procedure InsertAsmItemEntryRelation(ItemLedgerEntry: Record "Item Ledger Entry")    begin        GetItem(ItemLedgerEntry."Item No.", true);        if Item."Item Tracking Code" <> '' then begin            TempItemEntryRelation."Item Entry No." := ItemLedgerEntry."Entry No.";            TempItemEntryRelation.CopyTrackingFromItemLedgEntry(ItemLedgerEntry);            OnBeforeTempItemEntryRelationInsert(TempItemEntryRelation, ItemLedgerEntry);            TempItemEntryRelation.Insert();        end;    end;    local procedure TransReserveFromJobPlanningLine(FromJobContractEntryNo: Integer; ToItemJnlLine: Record "Item Journal Line")    var        JobPlanningLine: Record "Job Planning Line";    begin        JobPlanningLine.SetCurrentKey("Job Contract Entry No.");        JobPlanningLine.SetRange("Job Contract Entry No.", FromJobContractEntryNo);        JobPlanningLine.FindFirst();        TempJobPlanningLine := JobPlanningLine;        if not TempJobPlanningLine.Insert() then            TempJobPlanningLine.Find();        if TempJobPlanningLine."Remaining Qty. (Base)" >= ToItemJnlLine."Quantity (Base)" then            TempJobPlanningLine."Remaining Qty. (Base)" := TempJobPlanningLine."Remaining Qty. (Base)" - ToItemJnlLine."Quantity (Base)"        else            TempJobPlanningLine."Remaining Qty. (Base)" := 0;        TempJobPlanningLine.Modify();        JobPlanningLineReserve.TransferJobLineToItemJnlLine(TempJobPlanningLine, ToItemJnlLine, ToItemJnlLine."Quantity (Base)");    end;    /// <summary>    /// Splits a journal line based on the current global tracking specification line and stores it into a global buffer.    /// </summary>    /// <param name="ItemJnlLine2">Item journal line to split.</param>    /// <param name="SignFactor">Sign factor to multiply all amounts with.</param>    /// <param name="NonDistrQuantity">Total quantity used for determining the splitting factor.</param>    /// <param name="NonDistrAmount">Total amount to split and set.</param>    /// <param name="NonDistrAmountACY">Total Amount (ACY) to split and set.</param>    /// <param name="NonDistrDiscountAmount">Discount amount to split and set.</param>    /// <param name="Invoice">Indicates if journal line was already invoiced.</param>    /// <returns>True if created split item journal line needs to be posted, otherwise false.</returns>    procedure SetupTempSplitItemJnlLine(ItemJnlLine2: Record "Item Journal Line"; SignFactor: Integer; var NonDistrQuantity: Decimal; var NonDistrAmount: Decimal; var NonDistrAmountACY: Decimal; var NonDistrDiscountAmount: Decimal; Invoice: Boolean): Boolean    var        FloatingFactor: Decimal;        PostItemJnlLine: Boolean;        IsHandled: Boolean;    begin        OnBeforeSetupTempSplitItemJnlLine(ItemJnlLine2, SignFactor, NonDistrQuantity, NonDistrAmount, NonDistrAmountACY, NonDistrDiscountAmount, Invoice, IsHandled);        if isHandled then            exit;        TempSplitItemJnlLine."Quantity (Base)" := SignFactor * TempTrackingSpecification."Qty. to Handle (Base)";        TempSplitItemJnlLine.Quantity := SignFactor * TempTrackingSpecification."Qty. to Handle";        if Invoice then begin            TempSplitItemJnlLine."Invoiced Quantity" := SignFactor * TempTrackingSpecification."Qty. to Invoice";            TempSplitItemJnlLine."Invoiced Qty. (Base)" := SignFactor * TempTrackingSpecification."Qty. to Invoice (Base)";        end;        if ItemJnlLine2."Phys. Inventory" then            TempSplitItemJnlLine."Qty. (Phys. Inventory)" := TempSplitItemJnlLine."Qty. (Calculated)" + SignFactor * TempSplitItemJnlLine."Quantity (Base)";        OnAfterSetupTempSplitItemJnlLineSetQty(TempSplitItemJnlLine, ItemJnlLine2, SignFactor, TempTrackingSpecification);        FloatingFactor := TempSplitItemJnlLine.Quantity / NonDistrQuantity;        if FloatingFactor < 1 then begin            TempSplitItemJnlLine.Amount := Round(NonDistrAmount * FloatingFactor, GLSetup."Amount Rounding Precision");            TempSplitItemJnlLine."Amount (ACY)" := Round(NonDistrAmountACY * FloatingFactor, Currency."Amount Rounding Precision");            TempSplitItemJnlLine."Discount Amount" := Round(NonDistrDiscountAmount * FloatingFactor, GLSetup."Amount Rounding Precision");            NonDistrAmount := NonDistrAmount - TempSplitItemJnlLine.Amount;            NonDistrAmountACY := NonDistrAmountACY - TempSplitItemJnlLine."Amount (ACY)";            NonDistrDiscountAmount := NonDistrDiscountAmount - TempSplitItemJnlLine."Discount Amount";            NonDistrQuantity := NonDistrQuantity - TempSplitItemJnlLine.Quantity;            OnSetupTempSplitItemJnlLineOnAfterDeductNonDistr(TempSplitItemJnlLine);        end else begin            // the last record            TempSplitItemJnlLine.Amount := NonDistrAmount;            TempSplitItemJnlLine."Amount (ACY)" := NonDistrAmountACY;            TempSplitItemJnlLine."Discount Amount" := NonDistrDiscountAmount;        end;        if Round(TempSplitItemJnlLine."Unit Amount" * TempSplitItemJnlLine.Quantity, GLSetup."Amount Rounding Precision") <> TempSplitItemJnlLine.Amount then            if (TempSplitItemJnlLine."Unit Amount" = TempSplitItemJnlLine."Unit Cost") and (TempSplitItemJnlLine."Unit Cost" <> 0) then begin                TempSplitItemJnlLine."Unit Amount" := Round(TempSplitItemJnlLine.Amount / TempSplitItemJnlLine.Quantity, 0.00001);                TempSplitItemJnlLine."Unit Cost" := Round(TempSplitItemJnlLine.Amount / TempSplitItemJnlLine.Quantity, 0.00001);                TempSplitItemJnlLine."Unit Cost (ACY)" := Round(TempSplitItemJnlLine."Amount (ACY)" / TempSplitItemJnlLine.Quantity, 0.00001);            end else                TempSplitItemJnlLine."Unit Amount" := Round(TempSplitItemJnlLine.Amount / TempSplitItemJnlLine.Quantity, 0.00001);        TempSplitItemJnlLine.CopyTrackingFromSpec(TempTrackingSpecification);        TempSplitItemJnlLine."Item Expiration Date" := TempTrackingSpecification."Expiration Date";        TempSplitItemJnlLine.CopyNewTrackingFromNewSpec(TempTrackingSpecification);        TempSplitItemJnlLine."New Item Expiration Date" := TempTrackingSpecification."New Expiration Date";        OnSetupTempSplitItemJnlLineOnBeforeCalcPostItemJnlLine(TempSplitItemJnlLine, TempTrackingSpecification);        PostItemJnlLine := not TempSplitItemJnlLine.HasSameNewTracking() or (TempSplitItemJnlLine."Item Expiration Date" <> TempSplitItemJnlLine."New Item Expiration Date");        OnSetupTempSplitItemJnlLineOnAfterCalcPostItemJnlLine(TempSplitItemJnlLine, TempTrackingSpecification, PostItemJnlLine);        TempSplitItemJnlLine."Warranty Date" := TempTrackingSpecification."Warranty Date";        TempSplitItemJnlLine."Line No." := TempTrackingSpecification."Entry No.";        if TempTrackingSpecification.Correction or CheckDropShipmentForSetupTempSplitItemJnlLine(TempSplitItemJnlLine) or IsServUndoConsumption then            TempSplitItemJnlLine."Applies-to Entry" := TempTrackingSpecification."Item Ledger Entry No."        else            TempSplitItemJnlLine."Applies-to Entry" := TempTrackingSpecification."Appl.-to Item Entry";        TempSplitItemJnlLine."Applies-from Entry" := TempTrackingSpecification."Appl.-from Item Entry";        OnBeforeInsertSetupTempSplitItemJnlLine(TempTrackingSpecification, TempSplitItemJnlLine, PostItemJnlLine, ItemJnlLine2, SignFactor, FloatingFactor);        TempSplitItemJnlLine.Insert();        exit(PostItemJnlLine);    end;    local procedure PostInvtBuffer(var ValueEntry: Record "Value Entry")    begin        if InventoryPostingToGL.BufferInvtPosting(ValueEntry) then begin            OnPostInvtBufferOnAfterBufferInvtPosting(ValueEntry);            GetInvtSetup();            GetGLSetup();            if GLSetup."Journal Templ. Name Mandatory" then                InventoryPostingToGL.SetGenJnlBatch(                    InvtSetup."Invt. Cost Jnl. Template Name", InvtSetup."Invt. Cost Jnl. Batch Name");            InventoryPostingToGL.PostInvtPostBufPerEntry(ValueEntry);        end;    end;    local procedure VerifyTouchedOnInventory()    var        ItemLedgEntryApplied: Record "Item Ledger Entry";    begin        TempTouchedItemLedgerEntries.FindSet();        repeat            ItemLedgEntryApplied.Get(TempTouchedItemLedgerEntries."Entry No.");            ItemLedgEntryApplied.VerifyOnInventory(                StrSubstNo(CannotUnapplyItemLedgEntryErr, ItemLedgEntryApplied."Item No.", ItemLedgEntryApplied."Entry No."));        until TempTouchedItemLedgerEntries.Next() = 0;    end;    local procedure CheckIsCyclicalLoop(ItemLedgEntry: Record "Item Ledger Entry"; OldItemLedgEntry: Record "Item Ledger Entry"; var PrevAppliedItemLedgEntry: Record "Item Ledger Entry"; var AppliedQty: Decimal)    var        PrevProcessedProdOrder: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckIsCyclicalLoop(ItemLedgEntry, OldItemLedgEntry, PrevAppliedItemLedgEntry, AppliedQty, IsHandled);        if IsHandled then            exit;        PrevProcessedProdOrder :=          (ItemLedgEntry."Entry Type" = ItemLedgEntry."Entry Type"::Consumption) and          (OldItemLedgEntry."Entry Type" = OldItemLedgEntry."Entry Type"::Output) and          (ItemLedgEntry."Order Type" = ItemLedgEntry."Order Type"::Production) and          EntriesInTheSameOrder(OldItemLedgEntry, PrevAppliedItemLedgEntry);        if not PrevProcessedProdOrder then            if AppliedQty <> 0 then                if ItemLedgEntry.Positive then begin                    if ItemApplnEntry.CheckIsCyclicalLoop(ItemLedgEntry, OldItemLedgEntry) then                        AppliedQty := 0;                end else                    if ItemApplnEntry.CheckIsCyclicalLoop(OldItemLedgEntry, ItemLedgEntry) then                        AppliedQty := 0;        if AppliedQty <> 0 then            PrevAppliedItemLedgEntry := OldItemLedgEntry;    end;    local procedure EntriesInTheSameOrder(OldItemLedgEntry: Record "Item Ledger Entry"; PrevAppliedItemLedgEntry: Record "Item Ledger Entry"): Boolean    begin        exit(          (PrevAppliedItemLedgEntry."Order Type" = PrevAppliedItemLedgEntry."Order Type"::Production) and          (OldItemLedgEntry."Order Type" = OldItemLedgEntry."Order Type"::Production) and          (OldItemLedgEntry."Order No." = PrevAppliedItemLedgEntry."Order No.") and          (OldItemLedgEntry."Order Line No." = PrevAppliedItemLedgEntry."Order Line No."));    end;    local procedure MustConsiderUnitCostRoundingOnRevaluation(ItemJournalLine: Record "Item Journal Line"): Boolean    begin        exit(          (ItemJournalLine."Value Entry Type" = ItemJournalLine."Value Entry Type"::Revaluation) and          (GetItem(ItemJournalLine."Item No.", false) and (Item."Costing Method" = Item."Costing Method"::Average) or           (ItemJournalLine."Applies-to Entry" <> 0)));    end;    local procedure UpdateAppliedQtyIfConsumptionEntry(ItemLedgerEntry: Record "Item Ledger Entry"; OldItemLedgerEntry: Record "Item Ledger Entry"): Decimal    begin        if ItemLedgerEntry."Entry Type" <> ItemLedgerEntry."Entry Type"::Consumption then            exit(0);        if (ItemLedgerEntry."Remaining Quantity" + OldItemLedgerEntry."Remaining Quantity") > 0 then            exit(0);        exit(GetUpdatedAppliedQtyForConsumption(OldItemLedgerEntry, ItemLedgerEntry));    end;    procedure RunOnPublishPostingInventoryToGL()    begin        OnPublishPostingInventoryToGL(ItemJnlLine, InventoryPostingToGL);    end;    local procedure CheckIfReservationEntryForJobExist(): Boolean    var        JobPlanningLine: Record "Job Planning Line";        ReservationEntry: Record "Reservation Entry";    begin        JobPlanningLine.SetCurrentKey("Job Contract Entry No.");        JobPlanningLine.SetRange("Job Contract Entry No.", ItemJnlLine."Job Contract Entry No.");        if not JobPlanningLine.FindFirst() then            exit(false);        exit(JobPlanningLineReserve.FindReservEntry(JobPlanningLine, ReservationEntry));    end;    local procedure GetUpdatedAppliedQtyForConsumption(OldItemLedgerEntry: Record "Item Ledger Entry"; ItemLedgerEntry: Record "Item Ledger Entry") AppliedQty: Decimal    var        ReservationEntry: Record "Reservation Entry";        ReservationEntry2: Record "Reservation Entry";        SourceType: Integer;    begin        if OldItemLedgerEntry."Reserved Quantity" = 0 then            exit(0);        ReservationEntry.SetLoadFields("Entry No.", Positive, "Source Type", "Source Ref. No.");        ReservationEntry.SetRange("Source Type", Database::"Item Ledger Entry");        ReservationEntry.SetRange("Source Ref. No.", OldItemLedgerEntry."Entry No.");        if ReservationEntry.FindFirst() then            if ReservationEntry2.Get(ReservationEntry."Entry No.", not ReservationEntry.Positive) then                SourceType := ReservationEntry2."Source Type";        case SourceType of            Database::"Sales Line":                AppliedQty := -Abs(OldItemLedgerEntry."Remaining Quantity" - OldItemLedgerEntry."Reserved Quantity");            else                AppliedQty := -Abs(OldItemLedgerEntry."Reserved Quantity");        end;        OnAfterGetUpdatedAppliedQtyForConsumption(OldItemLedgerEntry, ItemLedgerEntry, ReservationEntry2, SourceType, AppliedQty);    end;    procedure PostDeferredValueEntriesToGL(PostponedValueEntries: List of [Integer])    var        ValueEntry: Record "Value Entry";        ValueEntryUpdate: Record "Value Entry";        Window: Dialog;        EntryNo: Integer;        FromEntryNo: Integer;        ToEntryNo: Integer;    begin        if PostponedValueEntries.Count = 0 then            exit;        if GuiAllowed then            Window.Open(PostToGlLbl);        FromEntryNo := 2100000000;        ToEntryNo := -2100000000;        // to find the range of postponed value entries        foreach EntryNo in PostponedValueEntries do begin            if EntryNo < FromEntryNo then                FromEntryNo := EntryNo;            if EntryNo > ToEntryNo then                ToEntryNo := EntryNo;        end;        ValueEntryUpdate.ReadIsolation(IsolationLevel::UpdLock);        ValueEntry.ReadIsolation(IsolationLevel::ReadUncommitted);  // we already locked the ones we need to update        ValueEntry.SetRange("Entry No.", FromEntryNo, ToEntryNo);        EntryNo := 0;        if ValueEntry.FindSet() then            repeat                if PostponedValueEntries.Contains(ValueEntry."Entry No.") then begin                    PostponedValueEntries.Remove(ValueEntry."Entry No.");                    EntryNo += 1;                    if GuiAllowed then                        Window.Update(1, EntryNo);                    ValueEntryUpdate := ValueEntry;                    PostValueEntryToGL(ValueEntryUpdate);                    ValueEntryUpdate.Modify();                end;            until ValueEntry.Next() = 0;        if GuiAllowed then            Window.Close();    end;    local procedure IsNondeductibleAndUseItemCost(): Boolean    var        VATSetup: Record "VAT Setup";    begin        if (VATSetup.Get()) and (VATSetup."Enable Non-Deductible VAT") and           (VATSetup."Use For Item Cost") and           (Item."Costing Method" <> Item."Costing Method"::Standard) and           (ItemJnlLine."Value Entry Type" = ItemJnlLine."Value Entry Type"::"Direct Cost") and           (ItemJnlLine."Item Charge No." = '') and           (ItemJnlLine."Applies-from Entry" = 0) and           not ItemJnlLine.Adjustment and (ItemJnlLine."Document Type" <> ItemJnlLine."Document Type"::"Inventory Receipt") and           (ItemJnlLine."Entry Type" <> ItemJnlLine."Entry Type"::Sale) then            exit(true);        exit(false);    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeAllowProdApplication(OldItemLedgerEntry: Record "Item Ledger Entry"; ItemLedgerEntry: Record "Item Ledger Entry"; var AllowApplication: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeApplyItemLedgEntry(var ItemLedgEntry: Record "Item Ledger Entry"; var OldItemLedgEntry: Record "Item Ledger Entry"; var ValueEntry: Record "Value Entry"; CausedByTransfer: Boolean; var Handled: Boolean; ItemJnlLine: Record "Item Journal Line"; var ItemApplnEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeApplyItemLedgEntrySetFilters(var ToItemLedgEntry: Record "Item Ledger Entry"; FromItemLedgEntry: Record "Item Ledger Entry"; ItemTrackingCode: Record "Item Tracking Code"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckApplication(ItemLedgerEntry: Record "Item Ledger Entry"; OldItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckExpirationDate(var ItemJournalLine: Record "Item Journal Line"; var TrackingSpecification: Record "Tracking Specification"; SignFactor: Integer; CalcExpirationDate: Date; var ExpirationDateChecked: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckLotNoInfoNotBlocked(var ItemJnlLine2: Record "Item Journal Line"; var IsHandled: Boolean; var ItemTrackingSetup: Record "Item Tracking Setup"; var TrackingSpecification: Record "Tracking Specification")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckItemCorrection(ItemLedgerEntry: Record "Item Ledger Entry"; var RaiseError: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckItemTracking(var ItemJournalLine: Record "Item Journal Line"; ItemTrackingSetup: Record "Item Tracking Setup"; var IsHandled: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckItemTrackingInformation(var ItemJnlLine2: Record "Item Journal Line"; var TrackingSpecification: Record "Tracking Specification"; var ItemTrackingSetup: Record "Item Tracking Setup"; var SignFactor: Decimal; var ItemTrackingCode: Record "Item Tracking Code"; var IsHandled: Boolean; var GlobalItemTrackingCode: Record "Item Tracking Code")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterAppliedEntriesToReadjust(ItemLedgEntry: Record "Item Ledger Entry"; var Readjust: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcAdjustedCost(var ItemJournalLine: Record "Item Journal Line"; var AdjustedCostLCY: Decimal; var AdjustedCostACY: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckItemTracking(ItemJournalLine: Record "Item Journal Line"; ItemTrackingSetup: Record "Item Tracking Setup"; GlobalItemTrackingCode: Record "Item Tracking Code")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckItemTrackingInformation(var ItemJnlLine2: Record "Item Journal Line"; var TrackingSpecification: Record "Tracking Specification"; ItemTrackingSetup: Record "Item Tracking Setup"; Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitCorrItemLedgEntry(var NewItemLedgEntry: Record "Item Ledger Entry"; EntriesExist: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckIfItemIsBlocked(var ItemJournalLine: Record "Item Journal Line"; CalledFromAdjustment: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCheckRunItemValuePosting(var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateItemJnlLineFromEntry(var ItemJournalLine: Record "Item Journal Line"; ItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertTempSplitItemJnlLine(var TempSplitItemJournalLine: Record "Item Journal Line" temporary; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertApplEntry(var ItemLedgEntryNo: Integer; var InboundItemEntry: Integer; var OutboundItemEntry: Integer; var TransferedFromEntryNo: Integer; var PostingDate: Date; var Quantity: Decimal; var CostToApply: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetOutputComplInvcdDate(var ItemApplicationEntry: Record "Item Application Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertTransferEntry(var NewItemLedgerEntry: Record "Item Ledger Entry"; var OldItemLedgerEntry: Record "Item Ledger Entry"; var ItemJournalLine: Record "Item Journal Line")    begin    end;#if not CLEAN27    internal procedure RunOnAfterFlushOperation(var ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ItemJnlLine: Record "Item Journal Line");    begin        OnAfterFlushOperation(ProdOrder, ProdOrderLine, ItemJnlLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterFlushOperation(var ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ItemJnlLine: Record "Item Journal Line");    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforeGetItem(var Item: Record Item; ItemNo: Code[20]; Unconditionally: Boolean; var HasGotItem: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetItemVariant(var ItemVariant: Record "Item Variant"; ItemNo: Code[20]; VariantCode: Code[10]; Unconditionally: Boolean; var ReturnValue: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetSourceNo(ItemJournalLine: Record "Item Journal Line"; var Result: Code[20]; var IsHandled: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnAfterPostFlushedConsump(var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; OldItemJnlLine: Record "Item Journal Line")    begin        OnAfterPostFlushedConsump(ProdOrderComp, ProdOrderRoutingLine, OldItemJnlLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterPostFlushedConsump(var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; OldItemJnlLine: Record "Item Journal Line")    begin    end;#endif#if not CLEAN27    internal procedure RunOnAfterPostConsumption(var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ItemJnlLine2: Record "Item Journal Line");    begin        OnAfterPostConsumption(ProdOrderComp, ItemJnlLine2);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterPostConsumption(var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ItemJnlLine: Record "Item Journal Line");    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertPhysInvtLedgEntry(var PhysInventoryLedgerEntry: Record "Phys. Inventory Ledger Entry"; ItemJournalLine: Record "Item Journal Line"; LastSplitItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitItemLedgEntry(var NewItemLedgEntry: Record "Item Ledger Entry"; var ItemJournalLine: Record "Item Journal Line"; var ItemLedgEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitItemLedgEntryOnBeforeInit(var ItemLedgerEntry: Record "Item Ledger Entry"; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertItemLedgEntry(var ItemLedgerEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line"; var ItemLedgEntryNo: Integer; var ValueEntryNo: Integer; var ItemApplnEntryNo: Integer; GlobalValueEntry: Record "Value Entry"; TransferItem: Boolean; var InventoryPostingToGL: Codeunit "Inventory Posting To G/L"; var OldItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertItemLedgEntry(var ItemLedgerEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line"; TransferItem: Boolean; OldItemLedgEntry: Record "Item Ledger Entry"; ItemJournalLineOrigin: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertItemLedgEntryProcedure(var ItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertValueEntry(var ValueEntry: Record "Value Entry"; ItemJournalLine: Record "Item Journal Line"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertValueEntry(var ValueEntry: Record "Value Entry"; ItemJournalLine: Record "Item Journal Line"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntryNo: Integer; var InventoryPostingToGL: Codeunit "Inventory Posting To G/L"; CalledFromAdjustment: Boolean; var OldItemLedgEntry: Record "Item Ledger Entry"; var Item: Record Item; TransferItem: Boolean; var GlobalValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertValueEntryProcedure(var ItemLedgerEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitValueEntry(var ValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line"; var ValueEntryNo: Integer; var ItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertCapLedgEntry(var CapLedgEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertCapLedgEntry(var CapLedgEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; ItemJournalLine: Record "Item Journal Line"; LastOperation: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertCapValueEntry(var ValueEntry: Record "Value Entry"; ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertCapValueEntryProcedure(ItemJournalLine: Record "Item Journal Line"; ValueEntryType: Enum "Cost Entry Type"; var ValuedQty: Decimal; var InvdQty: Decimal; var AdjdCost: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertCapValueEntry(var ValueEntry: Record "Value Entry"; ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertCorrItemLedgEntry(var NewItemLedgerEntry: Record "Item Ledger Entry"; var OldItemLedgerEntry: Record "Item Ledger Entry"; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertCorrItemLedgEntry(var NewItemLedgerEntry: Record "Item Ledger Entry"; var ItemJournalLine: Record "Item Journal Line"; var OldItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertCorrValueEntry(var NewValueEntry: Record "Value Entry"; OldValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line"; Sign: Integer; CalledFromAdjustment: Boolean; var ItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntryNo: Integer; var InventoryPostingToGL: Codeunit "Inventory Posting To G/L")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertCorrValueEntry(var NewValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntryNo: Integer)    begin    end;#if not CLEAN27    internal procedure RunOnBeforeInsertConsumpEntry(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; QtyBase: Decimal; var ModifyProdOrderComp: Boolean; var ItemJnlLine: Record "Item Journal Line"; var TempSplitItemJnlLine: Record "Item Journal Line" temporary)    begin        OnBeforeInsertConsumpEntry(ProdOrderComponent, QtyBase, ModifyProdOrderComp, ItemJnlLine, TempSplitItemJnlLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertConsumpEntry(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; QtyBase: Decimal; var ModifyProdOrderComp: Boolean; var ItemJnlLine: Record "Item Journal Line"; var TempSplitItemJnlLine: Record "Item Journal Line" temporary)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnAfterItemApplnEntryInsert(var ItemApplicationEntry: Record "Item Application Entry"; GlobalItemLedgerEntry: Record "Item Ledger Entry"; OldItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterItemQtyPosting(ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeItemApplnEntryInsert(var ItemApplicationEntry: Record "Item Application Entry"; GlobalItemLedgerEntry: Record "Item Ledger Entry"; OldItemLedgerEntry: Record "Item Ledger Entry"; var ItemApplnEntryNo: Integer)    begin    end;#if not CLEAN27    internal procedure RunOnBeforeNextOperationExist(var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line")    begin        OnBeforeNextOperationExist(ProdOrderRoutingLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeNextOperationExist(var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line")    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforePostItem(var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean; CalledFromAdjustment: Boolean; ItemRegister: Record "Item Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; CalledFromAdjustment: Boolean; CalledFromInvtPutawayPick: Boolean; var ItemRegister: Record "Item Register"; var ItemLedgEntryNo: Integer; var ValueEntryNo: Integer; var ItemApplnEntryNo: Integer; var PhysicalInventoryEntryNo: Integer; var CapacityLedgerEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetCommitBehavior(var IgnoreCommit: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetValueEntrySourceFieldsFromItemJnlLine(var ValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; ItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntryNo: Integer; var InventoryPostingToGL: Codeunit "Inventory Posting To G/L"; CalledFromAdjustment: Boolean; CalledFromInvtPutawayPick: Boolean; var ItemRegister: Record "Item Register"; var ItemLedgEntryNo: Integer; var ItemApplnEntryNo: Integer; var WhseJnlRegisterLine: Codeunit "Whse. Jnl.-Register Line"; var PhysicalInventoryEntryNo: Integer; var CapacityLedgerEntryNo: Integer)    begin    end;#if not CLEAN27    internal procedure RunOnAfterPostOutput(var ItemLedgerEntry: Record "Item Ledger Entry"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ItemJournalLine: Record "Item Journal Line")    begin        OnAfterPostOutput(ItemLedgerEntry, ProdOrderLine, ItemJournalLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterPostOutput(var ItemLedgerEntry: Record "Item Ledger Entry"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ItemJournalLine: Record "Item Journal Line")    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputOnBeforeProdOrderRtngLineModify(var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ItemJournalLine: Record "Item Journal Line"; var LastOperation: Boolean)    begin        OnPostOutputOnBeforeProdOrderRtngLineModify(ProdOrderRoutingLine, ProdOrderLine, ItemJournalLine, LastOperation);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnBeforeProdOrderRtngLineModify(var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ItemJournalLine: Record "Item Journal Line"; var LastOperation: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputOnAfterProdOrderRtngLineSetFilters(var ProdOrderRtngLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line")    begin        OnPostOutputOnAfterProdOrderRtngLineSetFilters(ProdOrderRtngLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnAfterProdOrderRtngLineSetFilters(var ProdOrderRtngLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line")    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnCheckPostingCostToGL(var PostCostToGL: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckExpirationDateOnBeforeTestFieldExpirationDate(var TempTrackingSpecification: Record "Tracking Specification" temporary; var EntriesExist: Boolean; var ExistingExpirationDate: Date);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertSetupTempSplitItemJnlLine(var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempItemJournalLine: Record "Item Journal Line" temporary; var PostItemJnlLine: Boolean; var ItemJournalLine2: Record "Item Journal Line"; SignFactor: Integer; FloatingFactor: Decimal)    begin    end;#if not CLEAN27    internal procedure RunOnBeforeFlushOperation(var ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ItemJnlLine: Record "Item Journal Line"; LastOperation: Boolean);    begin        OnBeforeFlushOperation(ProdOrder, ProdOrderLine, ItemJnlLine, LastOperation);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(true, false)]    local procedure OnBeforeFlushOperation(var ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ItemJnlLine: Record "Item Journal Line"; LastOperation: Boolean);    begin    end;#endif#if not CLEAN27    internal procedure RunOnBeforePostFlushedConsumpItemJnlLine(var ItemJournalLine: Record "Item Journal Line")    begin        OnBeforePostFlushedConsumpItemJnlLine(ItemJournalLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforePostFlushedConsumpItemJnlLine(var ItemJournalLine: Record "Item Journal Line")    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateOldItemLedgerEntryRemainingQuantity(var OldItemLedgerEntry: Record "Item Ledger Entry"; AppliedQuantity: Decimal; var GlobalItemLedgEntry: Record "Item Ledger Entry"; var AverageTransfer: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateItemLedgerEntryRemainingQuantity(var ItemLedgerEntry: Record "Item Ledger Entry"; AppliedQuantity: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterItemValuePosting(var ValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line"; var Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnAfterInsertTransferEntry(var ItemLedgerEntry: Record "Item Ledger Entry"; var OldItemLedgerEntry: Record "Item Ledger Entry"; AppliedQuantity: Decimal; CausedByTransfer: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupSplitJnlLineOnBeforeSplitTempLines(var TempSplitItemJournalLine: Record "Item Journal Line" temporary; var TempTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupSplitJnlLineOnAfterCheckExpirationDate(var ItemJnlLine2: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupSplitJnlLineOnBeforeCheckUseExpirationDates(var ItemJnlLine2: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; Item: Record Item; var CalcExpirationDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupSplitJnlLineOnAfterGetItemTrackingSetup(ItemTrackingCode: Record "Item Tracking Code"; ItemJnlLine: Record "Item Journal Line"; var ItemTrackingSetup: Record "Item Tracking Setup"; GlobalItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupSplitJnlLineOnBeforeGetItemTrackingSetup(var ItemJnlLine2: Record "Item Journal Line"; TrackingSpecExists: Boolean; CalledFromAdjustment: Boolean; var Item: Record Item; var ItemTrackingCode: Record "Item Tracking Code")    begin    end;    [InternalEvent(false)]    local procedure OnSetupSplitJnlLineOnSetDisableItemTracking(var ItemJournalLine: Record "Item Journal Line"; var DisableItemTracking: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupSplitJnlLineOnAfterCalcInvoice(var ItemJournalLine: Record "Item Journal Line"; var Invoice: Boolean)    begin    end;    [InternalEvent(false)]    local procedure OnSetupSplitJnlLineOnCheckOperationNo(var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupSplitJnlLineOnAfterSetupTempSplitItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var TempSplitItemJournalLine: Record "Item Journal Line" temporary; TempTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcExpectedCost(var ValueEntry: Record "Value Entry"; ItemLedgerEntryNo: Integer; var ExpectedCost: Decimal; var ExpectedCostACY: Decimal; var ExpectedSalesAmt: Decimal; var ExpectedPurchAmt: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcPurchCorrShares(var ValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line"; var OverheadAmount: Decimal; var OverheadAmountACY: Decimal; var VarianceAmount: Decimal; var VarianceAmountACY: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcPosShares(var ItemJournalLine: Record "Item Journal Line"; var DirCost: Decimal; var OvhdCost: Decimal; var PurchVar: Decimal; var DirCostACY: Decimal; var OvhdCostACY: Decimal; var PurchVarACY: Decimal; var CalcUnitCost: Boolean; CalcPurchVar: Boolean; Expected: Boolean; GlobalItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcPosShares(var ItemJournalLine: Record "Item Journal Line"; Expected: Boolean; CalcPurchVar: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertOHValueEntry(var ValueEntry: Record "Value Entry"; var Item: Record Item; var OverheadAmount: Decimal; var OverheadAmountACY: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSetupTempSplitItemJnlLineSetQty(var TempSplitItemJnlLine: Record "Item Journal Line" temporary; ItemJournalLine: Record "Item Journal Line"; SignFactor: Integer; var TempTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateAdjmtProp(var ValueEntry: Record "Value Entry"; OriginalPostingDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateUnitCost(ValueEntry: Record "Value Entry"; LastDirectCost: Decimal; ItemJournalLine: Record "Item Journal Line"; var Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcDirAndIndirCostAmts(var ItemJournalLine: Record "Item Journal Line"; var DirCostAmt: Decimal; var IndirCostAmt: Decimal; CapQty: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcExpirationDate(var ItemJnlLine: Record "Item Journal Line"; var ExpirationDate: Date; var IsHandled: Boolean; Item: Record Item)    begin    end;#if not CLEAN27    internal procedure RunOnBeforeCallFlushOperation(var ItemJnlLine2: Record "Item Journal Line"; var ShouldFlushOperation: Boolean);    begin        OnBeforeCallFlushOperation(ItemJnlLine2, ShouldFlushOperation);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeCallFlushOperation(var ItemJnlLine: Record "Item Journal Line"; var ShouldFlushOperation: Boolean);    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckSerialNo(ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean; var SkipSerialNoQtyValidation: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckItemTrackingIsEmpty(ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckIsCyclicalLoop(ItemLedgEntry: Record "Item Ledger Entry"; OldItemLedgEntry: Record "Item Ledger Entry"; var PrevAppliedItemLedgEntry: Record "Item Ledger Entry"; var AppliedQty: Decimal; var IsHandled: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnBeforePostFlushedConsump(ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; OldItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean);    begin        OnBeforePostFlushedConsump(ProdOrder, ProdOrderLine, ProdOrderComp, ProdOrderRoutingLine, OldItemJnlLine, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforePostFlushedConsump(ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; OldItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean);    begin    end;#endif    [IntegrationEvent(true, false)]    local procedure OnBeforeInitValueEntry(var ValueEntry: Record "Value Entry"; var ValueEntryNo: Integer; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertOHValueEntry(var ValueEntry: Record "Value Entry"; var Item: Record Item; var OverheadAmount: Decimal; var OverheadAmountACY: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertVarValueEntry(var ValueEntry: Record "Value Entry"; var Item: Record Item; var VarianceAmount: Decimal; var VarianceAmountACY: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertTempSplitItemJnlLine(ItemJournalLine: Record "Item Journal Line"; IsServUndoConsumption: Boolean; PostponeReservationHandling: Boolean; var TempSplitItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean; var PostItemJnlLine: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeMoveApplication(var ItemLedgEntry: Record "Item Ledger Entry"; var OldItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnMoveApplicationOnBeforeRemainingQtyCheck(var ItemLedgerEntry: Record "Item Ledger Entry"; var OldItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRedoApplicationsOnBeforeReApply(var TouchedItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeRedoApplications(var SkipDialog: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeOldItemLedgEntryModify(var OldItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostLineByEntryType(var ItemJournalLine: Record "Item Journal Line"; CalledFromAdjustment: Boolean; CalledFromInvtPutawayPick: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnBeforeProdOrderCompModify(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; ItemJournalLine: Record "Item Journal Line")    begin        OnBeforeProdOrderCompModify(ProdOrderComponent, ItemJournalLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeProdOrderCompModify(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; ItemJournalLine: Record "Item Journal Line")    begin    end;#endif#if not CLEAN27    internal procedure RunOnBeforeProdOrderLineModify(var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ItemJournalLine: Record "Item Journal Line"; ItemLedgEntryNo: Integer)    begin        OnBeforeProdOrderLineModify(ProdOrderLine, ItemJournalLine, ItemLedgEntryNo);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeProdOrderLineModify(var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ItemJournalLine: Record "Item Journal Line"; ItemLedgEntryNo: Integer)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforeRoundAmtValueEntry(var ValueEntry: Record "Value Entry"; Currency: Record Currency; Item: Record Item; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeRetrieveCostPerUnit(ItemJournalLine: Record "Item Journal Line"; SKU: Record "Stockkeeping Unit"; SKUExists: Boolean; var UnitCost: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeRunWithCheck(var ItemJournalLine: Record "Item Journal Line"; CalledFromAdjustment: Boolean; CalledFromInvtPutawayPick: Boolean; CalledFromApplicationWorksheet: Boolean; PostponeReservationHandling: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTempItemEntryRelationInsert(var TempItemEntryRelation: Record "Item Entry Relation" temporary; ItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTestFirstApplyItemLedgEntry(var OldItemLedgerEntry: Record "Item Ledger Entry"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTrackingSpecificationMissingErr(ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetOrderAdjmtProperties(ItemLedgEntryType: Option; OrderType: Option; OrderNo: Code[20]; OrderLineNo: Integer; OriginalPostingDate: Date; ValuationDate: Date; var IsHandled: Boolean; ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetupSplitJnlLine(var ItemJnlLine2: Record "Item Journal Line"; var TrackingSpecExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;#if not CLEAN28    [Obsolete('This event is no longer used.', '28.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeVerifyInvoicedQty(ItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean; ValueEntry: Record "Value Entry")    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforeVerifyItemJnlLineAsembleToOrder(var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUndoQuantityPosting(var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnBeforeUpdateProdOrderLine(var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ItemJournalLine: Record "Item Journal Line"; ReTrack: Boolean)    begin        OnBeforeUpdateProdOrderLine(ProdOrderLine, ItemJournalLine, ReTrack);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateProdOrderLine(var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ItemJournalLine: Record "Item Journal Line"; ReTrack: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateUnitCost(var ValueEntry: Record "Value Entry"; var IsHandled: Boolean; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateItemLedgerEntryRemainingQuantity(var ItemLedgerEntry: Record "Item Ledger Entry"; var OldItemLedgEntry: Record "Item Ledger Entry"; AppliedQty: Decimal; CausedByTransfer: Boolean; AverageTransfer: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnAfterCloseReservEntry(var OldItemLedgEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ReservEntry: Record "Reservation Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnBeforeCloseReservEntry(var OldItemLedgEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ReservEntry: Record "Reservation Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnBeforeTestOldItemLedgEntryLocationCode(var OldItemLedgEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnBeforeStartApplication(var ItemLedgerEntry: Record "Item Ledger Entry"; var OldItemLedgerEntry: Record "Item Ledger Entry"; var StartApplication: Boolean; var AppliedQty: Decimal; var Item: Record Item; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterApplyItemLedgEntrySetFilters(var ItemLedgerEntry2: Record "Item Ledger Entry"; ItemLedgerEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterApplyItemLedgEntryOnBeforeCalcAppliedQty(var OldItemLedgerEntry: Record "Item Ledger Entry"; ItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetGLSetup(var GeneralLedgerSetup: Record "General Ledger Setup")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterMoveValEntryDimToValEntryDim(var ToValueEntry: Record "Value Entry"; FromValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterInsertTransferEntry(var ItemJournalLine: Record "Item Journal Line"; NewItemLedgerEntry: Record "Item Ledger Entry"; OldItemLedgerEntry: Record "Item Ledger Entry"; NewValueEntry: Record "Value Entry"; var ValueEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostItem(var ItemJournalLine: Record "Item Journal Line"; CalledFromAdjustment: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostSplitJnlLine(var ItemJournalLine: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPrepareItem(var ItemJnlLineToPost: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUndoQuantityPosting(var ItemLedgerEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line")    begin    end;#if not CLEAN27    internal procedure RunOnAfterUpdateProdOrderLine(var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ReTrack: Boolean; var ItemJournalLine: Record "Item Journal Line")    begin        OnAfterUpdateProdOrderLine(ProdOrderLine, ReTrack, ItemJournalLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateProdOrderLine(var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ReTrack: Boolean; var ItemJournalLine: Record "Item Journal Line")    begin    end;#endif#if not CLEAN27    internal procedure RunOnAfterInsertConsumpEntry(var WarehouseJournalLine: Record "Warehouse Journal Line"; var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; QtyBase: Decimal; PostWhseJnlLine: Boolean; var ItemJnlLine: Record "Item Journal Line"; ItemLedgEntryNo: Integer)    begin        OnAfterInsertConsumpEntry(WarehouseJournalLine, ProdOrderComponent, QtyBase, PostWhseJnlLine, ItemJnlLine, ItemLedgEntryNo);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterInsertConsumpEntry(var WarehouseJournalLine: Record "Warehouse Journal Line"; var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; QtyBase: Decimal; PostWhseJnlLine: Boolean; var ItemJnlLine: Record "Item Journal Line"; ItemLedgEntryNo: Integer)    begin    end;#endif#if not CLEAN27    internal procedure RunOnApplyCapNeedOnAfterSetFilters(var ProdOrderCapNeed: Record Microsoft.Manufacturing.Document."Prod. Order Capacity Need"; ItemJnlLine: Record "Item Journal Line");    begin        OnApplyCapNeedOnAfterSetFilters(ProdOrderCapNeed, ItemJnlLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnApplyCapNeedOnAfterSetFilters(var ProdOrderCapNeed: Record Microsoft.Manufacturing.Document."Prod. Order Capacity Need"; ItemJnlLine: Record "Item Journal Line");    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnAfterCalcAppliedQty(OldItemLedgEntry: Record "Item Ledger Entry"; ItemLedgEntry: Record "Item Ledger Entry"; var AppliedQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnAfterSetAppliedQtyZero(OldItemLedgerEntry: Record "Item Ledger Entry"; var ItemLedgerEntry: Record "Item Ledger Entry"; var AppliedQty: Decimal; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnBeforeCheckApplyEntry(var OldItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnBeforeInsertApplEntry(var ItemLedgerEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line"; var OldItemLedgEntry: Record "Item Ledger Entry"; var GlobalItemLedgEntry: Record "Item Ledger Entry"; var AppliedQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnBeforeOldItemLedgEntryModify(var ItemLedgerEntry: Record "Item Ledger Entry"; var OldItemLedgerEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line"; var AverageTransfer: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCollectTrackingSpecification(var TempTrackingSpecification: Record "Tracking Specification" temporary; var TargetTrackingSpecification: Record "Tracking Specification" temporary; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcExpectedCostOnBeforeFindValueEntry(var ValueEntry: Record "Value Entry"; ItemLedgEntryNo: Integer; InvoicedQty: Decimal; Quantity: Decimal; var ExpectedCost: Decimal; var ExpectedCostACY: Decimal; var ExpectedSalesAmt: Decimal; var ExpectedPurchAmt: Decimal; CalcReminder: Boolean; var InvdValueEntry: Record "Value Entry"; ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcILEExpectedAmountOnBeforeCalcCostAmounts(var OldValueEntry2: Record "Value Entry"; var OldValueEntry: Record "Value Entry"; ItemLedgEntryNo: Integer)    begin    end;#if not CLEAN27    internal procedure RunOnCorrectOutputValuationDateOnBeforeCheckProdOrder(ItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin        OnCorrectOutputValuationDateOnBeforeCheckProdOrder(ItemLedgerEntry, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnCorrectOutputValuationDateOnBeforeCheckProdOrder(ItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnFlushOperationOnAfterProdOrderCompSetFilters(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; OldItemJournalLine: Record "Item Journal Line"; var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line")    begin        OnFlushOperationOnAfterProdOrderCompSetFilters(ProdOrderComponent, OldItemJournalLine, ProdOrderRoutingLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnFlushOperationOnAfterProdOrderCompSetFilters(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; OldItemJournalLine: Record "Item Journal Line"; var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line")    begin    end;#endif#if not CLEAN27    internal procedure RunOnFlushOperationOnBeforeCheckRoutingLinkCode(var ProductionOrder: Record Microsoft.Manufacturing.Document."Production Order"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; var ItemJournalLine: Record "Item Journal Line"; LastOperation: Boolean)    begin        OnFlushOperationOnBeforeCheckRoutingLinkCode(ProductionOrder, ProdOrderLine, ProdOrderRoutingLine, ItemJournalLine, LastOperation);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(true, false)]    local procedure OnFlushOperationOnBeforeCheckRoutingLinkCode(var ProductionOrder: Record Microsoft.Manufacturing.Document."Production Order"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; var ItemJournalLine: Record "Item Journal Line"; LastOperation: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnGetValuationDateOnAfterOldValueEntrySetFilters(var OldValueEntry: Record "Value Entry"; ValueEntry: Record "Value Entry"; OldItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetValuationDateOnBeforeFindOldValueEntry(var OldValueEntry: Record "Value Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitTransValueEntryOnAfterInitValueEntry(var ValueEntry: Record "Value Entry"; ItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitValueEntryOnAfterNotAdjustmentCheckClearCostAmount(var ValueEntry: Record "Value Entry"; var ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitValueEntryOnAfterSetValueEntryInventoriable(var ValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitValueEntryOnBeforeRoundAmtValueEntry(var ValueEntry: Record "Value Entry"; ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitValueEntryOnAfterAssignFields(var ValueEntry: Record "Value Entry"; ItemLedgEntry: Record "Item Ledger Entry"; ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitValueEntryOnAfterCalcInvoicedQuantityNotEmpty(var ItemJournalLine: Record "Item Journal Line"; var InvoicedQuantityNotEmpty: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitValueEntryOnAfterCalcDirestCost(var CostAmt: Decimal; var VarianceAmount: Decimal; Item: Record Item; ItemJournalLine: Record "Item Journal Line"; ValueEntry: Record "Value Entry"; var CostAmtACY: Decimal; var VarianceAmountACY: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertPostValueEntryToGLOnAfterTransferFields(var PostValueEntryToGL: Record "Post Value Entry to G/L"; ValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertTransferEntryOnTransferValues(var NewItemLedgerEntry: Record "Item Ledger Entry"; OldItemLedgerEntry: Record "Item Ledger Entry"; ItemLedgerEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line"; var TempItemEntryRelation: Record "Item Entry Relation"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertTransferEntryOnBeforeInitNewItemLedgEntry(var NewItemLedgerEntry: Record "Item Ledger Entry"; var OldItemLedgerEntry: Record "Item Ledger Entry"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ItemJournalLine: Record "Item Journal Line"; AppliedQuantity: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertCapValueEntryOnAfterUpdateCostAmounts(var ValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line")    begin    end;#if not CLEAN27    internal procedure RunOnInsertConsumpEntryOnBeforePostItem(var ItemJournalLine: Record "Item Journal Line"; ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; PostWhseJnlLine: Boolean; var WarehouseJournalLine: Record "Warehouse Journal Line")    begin        OnInsertConsumpEntryOnBeforePostItem(ItemJournalLine, ProdOrderComponent, PostWhseJnlLine, WarehouseJournalLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnInsertConsumpEntryOnBeforePostItem(var ItemJournalLine: Record "Item Journal Line"; ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; PostWhseJnlLine: Boolean; var WarehouseJournalLine: Record "Warehouse Journal Line")    begin    end;#endif    [IntegrationEvent(true, false)]    local procedure OnInsertOHValueEntryOnBeforeInsertValueEntry(var ValueEntry: Record "Value Entry"; ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean; var GlobalItemLedgEntry: Record "Item Ledger Entry"; var ValueEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnItemQtyPostingOnAfterCalcInsertItemLedgEntryNeeded(var ItemJournalLine: Record "Item Journal Line"; var InsertItemLedgEntryNeeded: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetRemainingQuantityAndFlags(var ItemJournalLine: Record "Item Journal Line"; var Item: Record Item; var GlobalItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnItemQtyPostingOnBeforeApplyItemLedgEntry(var ItemJournalLine: Record "Item Journal Line"; var ItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnItemValuePostingOnAfterInsertValueEntry(var ValueEntry: Record "Value Entry"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnItemValuePostingOnAfterCalcIsCostNotTracedDirectly(var ItemJnlLine: Record "Item Journal Line"; var IsCostNotTracedDirectly: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertItemLedgEntryOnBeforeReservationError(var ItemJournalLine: Record "Item Journal Line"; var ItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean; Location: Record Location)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertItemLedgEntryOnBeforeSNQtyCheck(ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertItemLedgEntryOnBeforeSetCompletelyInvoiced(var ItemLedgerEntry: Record "Item Ledger Entry"; var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertItemRegOnBeforeItemRegInsert(var ItemRegister: Record "Item Register"; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValuateAppliedAvgEntryOnAfterSetCostPerUnit(var ValueEntry: Record "Value Entry"; ItemJournalLine: Record "Item Journal Line"; InventorySetup: Record "Inventory Setup"; SKU: Record "Stockkeeping Unit"; SKUExists: Boolean; Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnValuateAppliedAvgEntryOnAfterUpdateCostAmounts(var ValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line")    begin    end;#if not CLEAN27    internal procedure RunOnPostFlushedConsumpOnAfterCalcQtyToPost(ProductionOrder: Record Microsoft.Manufacturing.Document."Production Order"; ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; ActOutputQtyBase: Decimal; var QtyToPost: Decimal; var OldItemJournalLine: Record "Item Journal Line"; var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; var CompItem: Record Item)    begin        OnPostFlushedConsumpOnAfterCalcQtyToPost(ProductionOrder, ProdOrderLine, ProdOrderComponent, ActOutputQtyBase, QtyToPost, OldItemJournalLine, ProdOrderRoutingLine, CompItem);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostFlushedConsumpOnAfterCalcQtyToPost(ProductionOrder: Record Microsoft.Manufacturing.Document."Production Order"; ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; ActOutputQtyBase: Decimal; var QtyToPost: Decimal; var OldItemJournalLine: Record "Item Journal Line"; var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; var CompItem: Record Item)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostFlushedConsumpOnAfterCopyProdOrderFieldsToItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var OldItemJournalLine: Record "Item Journal Line"; ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; CompItem: record Item)    begin        OnPostFlushedConsumpOnAfterCopyProdOrderFieldsToItemJnlLine(ItemJournalLine, OldItemJournalLine, ProdOrderLine, ProdOrderComponent, CompItem);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostFlushedConsumpOnAfterCopyProdOrderFieldsToItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var OldItemJournalLine: Record "Item Journal Line"; ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; CompItem: record Item)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostFlushedConsumptionOnBeforeCalcQtyToPost(ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; OldItemJnlLine: Record "Item Journal Line"; var OutputQtyBase: Decimal)    begin        OnPostFlushedConsumptionOnBeforeCalcQtyToPost(ProdOrder, ProdOrderLine, ProdOrderComp, ProdOrderRoutingLine, OldItemJnlLine, OutputQtyBase);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostFlushedConsumptionOnBeforeCalcQtyToPost(ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; OldItemJnlLine: Record "Item Journal Line"; var OutputQtyBase: Decimal)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostFlushedConsumpOnBeforeProdOrderCompReserveTransferPOCompToItemJnlLine(ItemJournalLine: Record "Item Journal Line"; ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component")    begin        OnPostFlushedConsumpOnBeforeProdOrderCompReserveTransferPOCompToItemJnlLine(ItemJournalLine, ProdOrderComponent);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostFlushedConsumpOnBeforeProdOrderCompReserveTransferPOCompToItemJnlLine(ItemJournalLine: Record "Item Journal Line"; ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component")    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostFlushedConsumpOnBeforeSetupSplitJnlLine(var ItemJournalLine: Record "Item Journal Line"; var ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecExists: Boolean)    begin        OnPostFlushedConsumpOnBeforeSetupSplitJnlLine(ItemJournalLine, ProdOrder, ProdOrderLine, ProdOrderComp, TempTrackingSpecification, TrackingSpecExists);    end;    [Obsolete('Replaced by event OnPostFlushedConsumptionItemJnlLineOnBeforeSetupSplitJnlLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostFlushedConsumpOnBeforeSetupSplitJnlLine(var ItemJournalLine: Record "Item Journal Line"; var ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecExists: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnPostFlushedConsumptionItemJnlLineOnBeforeSetupSplitJnlLine(var ItemJournalLine: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecExists: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnPostFlushedConsumptionOnAfterSetDimensionSetID(ItemJournalLine: Record "Item Journal Line"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line")    begin        OnPostFlushedConsumptionOnAfterSetDimensionSetID(ItemJournalLine, ProdOrderLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostFlushedConsumptionOnAfterSetDimensionSetID(ItemJournalLine: Record "Item Journal Line"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line")    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnPostFlushedConsumptionItemJnlLineOnAfterSetDimensionSetID(ItemJournalLine: Record "Item Journal Line")    begin    end;#if not CLEAN27    internal procedure RunOnPostConsumptionOnAfterInsertEntry(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component")    begin        OnPostConsumptionOnAfterInsertEntry(ProdOrderComponent);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostConsumptionOnAfterInsertEntry(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component")    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostConsumptionOnAfterFindProdOrderComp(var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component")    begin        OnPostConsumptionOnAfterFindProdOrderComp(ProdOrderComp);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostConsumptionOnAfterFindProdOrderComp(var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component")    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostConsumptionOnAfterCalcNewRemainingQty(ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var NewRemainingQuantity: Decimal; QtyToPost: Decimal)    begin        OnPostConsumptionOnAfterCalcNewRemainingQty(ProdOrderComponent, NewRemainingQuantity, QtyToPost);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostConsumptionOnAfterCalcNewRemainingQty(ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var NewRemainingQuantity: Decimal; QtyToPost: Decimal)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostConsumptionOnBeforeCheckOrderType(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin        OnPostConsumptionOnBeforeCheckOrderType(ProdOrderComponent, ItemJournalLine, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostConsumptionOnBeforeCheckOrderType(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostConsumptionOnBeforeFindSetProdOrderComp(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ItemJournalLine: Record "Item Journal Line")    begin        OnPostConsumptionOnBeforeFindSetProdOrderComp(ProdOrderComponent, ItemJournalLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostConsumptionOnBeforeFindSetProdOrderComp(var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ItemJournalLine: Record "Item Journal Line")    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnPostItemOnAfterGetSKU(var ItemJnlLine: Record "Item Journal Line"; var SKUExists: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemOnBeforeCheckInventoryPostingGroup(var ItemJnlLine: Record "Item Journal Line"; var CalledFromAdjustment: Boolean; var Item: Record Item; var ItemTrackingCode: Record "Item Tracking Code")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemOnBeforeUpdateUnitCost(var ItemJnlLine: Record "Item Journal Line"; GlobalItemLedgEntry: Record "Item Ledger Entry")    begin    end;#if not CLEAN27    internal procedure RunOnPostOutputOnAfterInsertCapLedgEntry(ItemJournalLine: Record "Item Journal Line"; var SkipPost: Boolean)    begin        OnPostOutputOnAfterInsertCapLedgEntry(ItemJournalLine, SkipPost);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnAfterInsertCapLedgEntry(ItemJournalLine: Record "Item Journal Line"; var SkipPost: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputOnAfterInsertCostValueEntries(ItemJournalLine: Record "Item Journal Line"; var CapLedgEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; CalledFromAdjustment: Boolean; PostToGL: Boolean)    begin        OnPostOutputOnAfterInsertCostValueEntries(ItemJournalLine, CapLedgEntry, CalledFromAdjustment, PostToGL);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnAfterInsertCostValueEntries(ItemJournalLine: Record "Item Journal Line"; var CapLedgEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; CalledFromAdjustment: Boolean; PostToGL: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputOnAfterSetMfgUnitCost(var ItemJournalLine: Record "Item Journal Line"; var MfgUnitCost: Decimal; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line")    begin        OnPostOutputOnAfterSetMfgUnitCost(ItemJournalLine, MfgUnitCost, ProdOrderLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnAfterSetMfgUnitCost(var ItemJournalLine: Record "Item Journal Line"; var MfgUnitCost: Decimal; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line")    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputOnAfterUpdateAmounts(var ItemJournalLine: Record "Item Journal Line")    begin        OnPostOutputOnAfterUpdateAmounts(ItemJournalLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnAfterUpdateAmounts(var ItemJournalLine: Record "Item Journal Line")    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputOnAfterUpdateProdOrderLine(var ItemJournalLine: Record "Item Journal Line"; var WhseJnlLine: Record "Warehouse Journal Line"; var GlobalItemLedgEntry: Record "Item Ledger Entry");    begin        OnPostOutputOnAfterUpdateProdOrderLine(ItemJournalLine, WhseJnlLine, GlobalItemLedgEntry);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnAfterUpdateProdOrderLine(var ItemJournalLine: Record "Item Journal Line"; var WhseJnlLine: Record "Warehouse Journal Line"; var GlobalItemLedgEntry: Record "Item Ledger Entry");    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputOnBeforeUpdateProdOrderLine(var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin        OnPostOutputOnBeforeUpdateProdOrderLine(ItemJournalLine, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnBeforeUpdateProdOrderLine(var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputOnAfterCreateWhseJnlLine(var ItemJournalLine: Record "Item Journal Line")    begin        OnPostOutputOnAfterCreateWhseJnlLine(ItemJournalLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnAfterCreateWhseJnlLine(var ItemJournalLine: Record "Item Journal Line")    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputOnBeforeCreateWhseJnlLine(var ItemJournalLine: Record "Item Journal Line"; var PostWhseJnlLine: Boolean)    begin        OnPostOutputOnBeforeCreateWhseJnlLine(ItemJournalLine, PostWhseJnlLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnBeforeCreateWhseJnlLine(var ItemJournalLine: Record "Item Journal Line"; var PostWhseJnlLine: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputOnBeforePostItem(var ItemJournalLine: Record "Item Journal Line"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var IsHandled: Boolean)    begin        OnPostOutputOnBeforePostItem(ItemJournalLine, ProdOrderLine, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnBeforePostItem(var ItemJournalLine: Record "Item Journal Line"; var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; var IsHandled: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnPostSplitJnlLineOnBeforeSplitJnlLine(var ItemJournalLine: Record "Item Journal Line"; var ItemJournalLineToPost: Record "Item Journal Line"; var PostItemJournalLine: Boolean; DisableItemTracking: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnReApplyOnBeforeStartApply(var ItemLedgerEntry: Record "Item Ledger Entry"; var ItemLedgerEntry2: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnReApplyOnBeforeCostApply(var ItemLedgerEntry: Record "Item Ledger Entry"; var ItemLedgerEntry2: Record "Item Ledger Entry"; var CostApplication: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnReApplyOnBeforeGetItemTrackingSetup(var Item: Record Item; var ItemTrackingCode: Record "Item Tracking Code")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnReApplyOnBeforeCreateItemJnlLineFromEntryApplyWithZero(var ItemLedgerEntry: Record "Item Ledger Entry"; var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetOrderAdjmtPropertiesOnBeforeSetCostIsAdjusted(var InvtAdjmtEntryOrder: Record "Inventory Adjmt. Entry (Order)"; var ModifyOrderAdjmt: Boolean; var IsHandled: Boolean; OriginalPostingDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetOrderAdjmtPropertiesOnBeforeSetAllowOnlineAdjustment(var InvtAdjmtEntryOrder: Record "Inventory Adjmt. Entry (Order)"; var ModifyOrderAdjmt: Boolean; var IsHandled: Boolean; OriginalPostingDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupSplitJnlLineOnBeforeReallocateTrkgSpecification(var ItemTrackingCode: Record "Item Tracking Code"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var ItemJnlLine: Record "Item Journal Line"; var SignFactor: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupSplitJnlLineOnBeforeCalcNonDistrQuantity(var TempTrackingSpecification: Record "Tracking Specification" temporary; var ItemJournalLine: Record "Item Journal Line"; Invoice: Boolean; SignFactor: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSplitItemJnlLineOnBeforeTracking(        var ItemJnlLine2: Record "Item Journal Line"; var PostItemJnlLine: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary;        var GlobalItemLedgEntry: Record "Item Ledger Entry"; var TempItemEntryRelation: Record "Item Entry Relation" temporary;        var PostponeReservationHandling: Boolean; var SignFactor: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnTestFirstApplyItemLedgEntryOnAfterTestFields(ItemLedgerEntry: Record "Item Ledger Entry"; OldItemLedgerEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTestFirstApplyItemLedgerEntryTracking(ItemLedgerEntry: Record "Item Ledger Entry"; OldItemLedgerEntry: Record "Item Ledger Entry"; var ItemTrackingCode: Record "Item Tracking Code")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterTestFirstApplyItemLedgerEntryTracking(ItemLedgEntry: Record "Item Ledger Entry"; OldItemLedgEntry: Record "Item Ledger Entry"; ItemTrackingCode: Record "Item Tracking Code")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnTouchItemEntryCostOnAfterAfterSetAdjmtProp(var ItemLedgerEntry: Record "Item Ledger Entry"; IsAdjustment: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnApplyOnBeforeUpdateItemLedgerEntries(var ItemLedgerEntry1: Record "Item Ledger Entry"; var ItemLedgerEntry2: Record "Item Ledger Entry"; ItemApplnEntry: Record "Item Application Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnApplyOnBeforeItemApplnEntryDelete(var ItemApplicationEntry: Record "Item Application Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateUnitCostOnBeforeCalculateLastDirectCost(var TotalAmount: Decimal; ItemJournalLine: Record "Item Journal Line"; ValueEntry: Record "Value Entry"; var Item: Record Item; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateUnitCostOnBeforeUpdateUnitCost(ItemJournalLine: Record "Item Journal Line"; ValueEntry: Record "Value Entry"; var Item: Record Item; var UpdateSKU: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostInventoryToGL(var ValueEntry: Record "Value Entry"; var IsHandled: Boolean; var ItemJnlLine: Record "Item Journal Line"; PostToGL: Boolean; CalledFromAdjustment: Boolean; ItemInventoryValueZero: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostValueEntryToGL(var ValueEntry: Record "Value Entry"; var IsHandled: Boolean; PostToGL: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostInventoryToGL(var ValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostSplitJnlLineOnAfterCode(var ItemJournalLine: Record "Item Journal Line"; var ItemJournalLineToPost: Record "Item Journal Line"; var PostItemJournalLine: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; DisableItemTracking: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnAfterCalcCapQty(var ItemJnlLine: Record "Item Journal Line"; var CapQty: Decimal)    begin        OnAfterCalcCapQty(ItemJnlLine, CapQty);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterCalcCapQty(var ItemJnlLine: Record "Item Journal Line"; var CapQty: Decimal)    begin    end;#endif    /// <summary>    /// Prepares provided item journal line for posting and copies it to the global ItemJnlLine record.    /// </summary>    /// <remarks>    /// If General Ledger Setup has additional reporting currency record, that record is retrieved     /// and mandatory fields are checked. Checks if an item and its variant are blocked and retrieve their records     /// if they are not.    /// </remarks>    /// <param name="ItemJnlLineToPost">Item journal line to prepare.</param>    procedure PrepareItem(var ItemJnlLineToPost: Record "Item Journal Line")    begin        ItemJnlLine.Copy(ItemJnlLineToPost);        GetGLSetup();        GetInvtSetup();        CheckItemAndItemVariant(ItemJnlLineToPost."Item No.", ItemJnlLineToPost."Variant Code");        OnAfterPrepareItem(ItemJnlLineToPost);    end;    /// <summary>    /// Sets the value of the global flag SkipApplicationCheck.    /// </summary>    /// <remarks>    /// If true, then application check is not executed when an item ledger entry is applied to another item ledger entry.    /// </remarks>    /// <param name="NewValue">The new value to set.</param>    procedure SetSkipApplicationCheck(NewValue: Boolean)    begin        SkipApplicationCheck := NewValue;    end;    /// <summary>    /// Logs the application of an item ledger entry by creating a new item application entry record and     /// adding it to the global temporary item application entry history record set.    /// </summary>    /// <param name="ApplyItemLedgEntry">Inbound item ledger entry record.</param>    /// <param name="AppliedItemLedgEntry">Applied item ledger entry record.</param>    procedure LogApply(ApplyItemLedgEntry: Record "Item Ledger Entry"; AppliedItemLedgEntry: Record "Item Ledger Entry")    var        ItemApplnEntry: Record "Item Application Entry";    begin        ItemApplnEntry.Init();        if AppliedItemLedgEntry.Quantity > 0 then begin            ItemApplnEntry."Item Ledger Entry No." := ApplyItemLedgEntry."Entry No.";            ItemApplnEntry."Inbound Item Entry No." := AppliedItemLedgEntry."Entry No.";            ItemApplnEntry."Outbound Item Entry No." := ApplyItemLedgEntry."Entry No.";        end else begin            ItemApplnEntry."Item Ledger Entry No." := AppliedItemLedgEntry."Entry No.";            ItemApplnEntry."Inbound Item Entry No." := ApplyItemLedgEntry."Entry No.";            ItemApplnEntry."Outbound Item Entry No." := AppliedItemLedgEntry."Entry No.";        end;        AddToApplicationLog(ItemApplnEntry, true);    end;    /// <summary>    /// Logs un-application of an item ledger entry to the global temporary item application entry history record set     /// with cost application set to false.    /// </summary>    /// <param name="ItemApplnEntry">Item application entry to log.</param>    procedure LogUnapply(ItemApplnEntry: Record "Item Application Entry")    begin        AddToApplicationLog(ItemApplnEntry, false);    end;    local procedure AddToApplicationLog(ItemApplnEntry: Record "Item Application Entry"; IsApplication: Boolean)    begin        if TempItemApplnEntryHistory.FindLast() then;        TempItemApplnEntryHistory."Primary Entry No." += 1;        TempItemApplnEntryHistory."Item Ledger Entry No." := ItemApplnEntry."Item Ledger Entry No.";        TempItemApplnEntryHistory."Inbound Item Entry No." := ItemApplnEntry."Inbound Item Entry No.";        TempItemApplnEntryHistory."Outbound Item Entry No." := ItemApplnEntry."Outbound Item Entry No.";        TempItemApplnEntryHistory."Cost Application" := IsApplication;        TempItemApplnEntryHistory.Insert();    end;    /// <summary>    /// Clears the global item application entry history temporary record set.    /// </summary>    procedure ClearApplicationLog()    begin        TempItemApplnEntryHistory.DeleteAll();    end;    /// <summary>    /// Undoes the applications of item ledger entries based on the records in the global     /// item application entry history temporary record set.    /// </summary>    /// <remarks>    /// Used during undo manual changes action on application worksheet page.    /// </remarks>    procedure UndoApplications()    var        ItemLedgEntry: Record "Item Ledger Entry";        ItemApplnEntry: Record "Item Application Entry";    begin        TempItemApplnEntryHistory.Ascending(false);        if TempItemApplnEntryHistory.FindSet() then            repeat                if TempItemApplnEntryHistory."Cost Application" then begin                    ItemApplnEntry.SetRange("Inbound Item Entry No.", TempItemApplnEntryHistory."Inbound Item Entry No.");                    ItemApplnEntry.SetRange("Outbound Item Entry No.", TempItemApplnEntryHistory."Outbound Item Entry No.");                    ItemApplnEntry.FindFirst();                    UnApply(ItemApplnEntry);                end else begin                    ItemLedgEntry.Get(TempItemApplnEntryHistory."Item Ledger Entry No.");                    SetSkipApplicationCheck(true);                    ReApply(ItemLedgEntry, TempItemApplnEntryHistory."Inbound Item Entry No.");                end;            until TempItemApplnEntryHistory.Next() = 0;        ClearApplicationLog();        TempItemApplnEntryHistory.Ascending(true);    end;    /// <summary>    /// Returns whether the global item application entry history record set is empty.    /// </summary>    /// <returns>True if item application entry history record set is empty, otherwise false.</returns>    procedure ApplicationLogIsEmpty(): Boolean    begin        exit(TempItemApplnEntryHistory.IsEmpty);    end;    local procedure AppliedEntriesToReadjust(ItemLedgEntry: Record "Item Ledger Entry") Readjust: Boolean    begin        Readjust := ItemLedgEntry."Entry Type" in [ItemLedgEntry."Entry Type"::Output, ItemLedgEntry."Entry Type"::"Assembly Output"];        OnAfterAppliedEntriesToReadjust(ItemLedgEntry, Readjust);    end;    local procedure GetTextStringWithLineNo(BasicTextString: Text; ItemNo: Code[20]; LineNo: Integer): Text    begin        if LineNo = 0 then            exit(StrSubstNo(BasicTextString, ItemNo));        exit(StrSubstNo(BasicTextString, ItemNo) + StrSubstNo(LineNoTxt, LineNo));    end;    /// <summary>    /// Returns the value of the global flag CalledFromAdjustment.    /// </summary>    /// <returns>The value of the global flag CalledFromAdjustment.</returns>    procedure GetCalledFromAdjustment(): Boolean    begin        exit(CalledFromAdjustment);    end;    /// <summary>    /// Returns the value of the global flag CalledFromInvtPutawayPick.    /// </summary>    /// <returns>The value of the global flag CalledFromInvtPutawayPick.</returns>    procedure GetCalledFromInvtPutawayPick(): Boolean    begin        exit(CalledFromInvtPutawayPick);    end;    /// <summary>    /// Sets the value of the global flag CalledFromApplicationWorksheet.    /// </summary>    /// <remarks>    /// If false, then touched entries are not tracked.    /// </remarks>    /// <param name="IsCalledFromApplicationWorksheet">The new value to set.</param>    procedure SetCalledFromApplicationWorksheet(IsCalledFromApplicationWorksheet: Boolean)    begin        CalledFromApplicationWorksheet := IsCalledFromApplicationWorksheet;    end;    local procedure SaveTouchedEntry(ItemLedgerEntryNo: Integer; IsInbound: Boolean)    var        ItemApplicationEntryHistory: Record "Item Application Entry History";        NextEntryNo: Integer;    begin        if not CalledFromApplicationWorksheet then            exit;        NextEntryNo := ItemApplicationEntryHistory.GetNextEntryNo();        ItemApplicationEntryHistory.Init();        ItemApplicationEntryHistory."Primary Entry No." := NextEntryNo;        ItemApplicationEntryHistory."Entry No." := 0;        ItemApplicationEntryHistory."Item Ledger Entry No." := ItemLedgerEntryNo;        if IsInbound then            ItemApplicationEntryHistory."Inbound Item Entry No." := ItemLedgerEntryNo        else            ItemApplicationEntryHistory."Outbound Item Entry No." := ItemLedgerEntryNo;        ItemApplicationEntryHistory."Creation Date" := CurrentDateTime;        ItemApplicationEntryHistory."Created By User" := UserId;        ItemApplicationEntryHistory.Insert(true);    end;    /// <summary>    /// Marks the entries that were previously modified by the current user as touched. Items of these entries are added to TempItem.    /// </summary>    /// <remarks>    /// Used when opening the application worksheet.    /// </remarks>    /// <param name="TempItem">Return value: A collection of items of touched entries.</param>    procedure RestoreTouchedEntries(var TempItem: Record Item temporary)    var        ItemApplicationEntryHistory: Record "Item Application Entry History";        ItemLedgerEntry: Record "Item Ledger Entry";    begin        ItemApplicationEntryHistory.SetRange("Entry No.", 0);        ItemApplicationEntryHistory.SetRange("Created By User", UpperCase(UserId));        if ItemApplicationEntryHistory.FindSet() then            repeat                TouchEntry(ItemApplicationEntryHistory."Item Ledger Entry No.");                ItemLedgerEntry.Get(ItemApplicationEntryHistory."Item Ledger Entry No.");                TempItem."No." := ItemLedgerEntry."Item No.";                if TempItem.Insert() then;            until ItemApplicationEntryHistory.Next() = 0;    end;    local procedure DeleteTouchedEntries()    var        ItemApplicationEntryHistory: Record "Item Application Entry History";    begin        if not CalledFromApplicationWorksheet then            exit;        ItemApplicationEntryHistory.SetRange("Entry No.", 0);        ItemApplicationEntryHistory.SetRange("Created By User", UpperCase(UserId));        ItemApplicationEntryHistory.DeleteAll();    end;    local procedure VerifyItemJnlLineAsembleToOrder(var ItemJournalLine: Record "Item Journal Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeVerifyItemJnlLineAsembleToOrder(ItemJournalLine, IsHandled);        if IsHandled then            exit;        ItemJournalLine.TestField("Applies-to Entry");        ItemJournalLine.CalcReservedQuantity();        ItemJournalLine.TestField("Reserved Qty. (Base)");    end;    local procedure VerifyItemJnlLineApplication(var ItemJournalLine: Record "Item Journal Line"; ItemLedgerEntry: Record "Item Ledger Entry")    var        SkipError: Boolean;    begin        if ItemJournalLine."Applies-to Entry" = 0 then            exit;        ItemJournalLine.CalcReservedQuantity();        if ItemJournalLine."Reserved Qty. (Base)" <> 0 then begin            SkipError := //posting together with PO                (ItemJournalLine."Document Type" = ItemJournalLine."Document Type"::"Purchase Receipt")                and (ItemJournalLine."Entry Type" = ItemJournalLine."Entry Type"::"Negative Adjmt.")                and (ItemJournalLine."Job No." <> '');            if not SkipError then                ItemLedgerEntry.FieldError("Applies-to Entry", Text99000000);        end;    end;    local procedure CalcILEExpectedAmount(var OldValueEntry: Record "Value Entry"; ItemLedgerEntryNo: Integer)    var        OldValueEntry2: Record "Value Entry";    begin        OldValueEntry.FindFirstValueEntryByItemLedgerEntryNo(ItemLedgerEntryNo);        OldValueEntry2.Copy(OldValueEntry);        OldValueEntry2.ReadIsolation(IsolationLevel::ReadUnCommitted);        OldValueEntry2.SetFilter("Entry No.", '<>%1', OldValueEntry."Entry No.");        OnCalcILEExpectedAmountOnBeforeCalcCostAmounts(OldValueEntry2, OldValueEntry, ItemLedgEntryNo);        OldValueEntry2.CalcSums("Cost Amount (Expected)", "Cost Amount (Expected) (ACY)");        OldValueEntry."Cost Amount (Expected)" += OldValueEntry2."Cost Amount (Expected)";        OldValueEntry."Cost Amount (Expected) (ACY)" += OldValueEntry2."Cost Amount (Expected) (ACY)";    end;    local procedure ExpectedCostPosted(ValueEntry: Record "Value Entry"): Boolean    var        PostedExpCostValueEntry: Record "Value Entry";    begin        if not ValueEntry.Adjustment or (ValueEntry."Applies-to Entry" = 0) then            exit(false);        PostedExpCostValueEntry.SetRange("Item Ledger Entry No.", ValueEntry."Item Ledger Entry No.");        PostedExpCostValueEntry.SetRange("Applies-to Entry", ValueEntry."Applies-to Entry");        PostedExpCostValueEntry.SetRange("Expected Cost", true);        exit(not PostedExpCostValueEntry.IsEmpty);    end;    /// <summary>    /// Sets the value of the global flag SkipSerialNoQtyValidation.    /// </summary>    /// <remarks>    /// If true and item tracking code has serial number specific tracking enabled, it skips the checks.    /// Enabled serial number specific tracking ensures that items are accurately traced with specific serial or lot numbers     /// both backward and forward in the supply chain, which is crucial for quality assurance and product recalls.    /// </remarks>    /// <param name="NewSkipSerialNoQtyValidation">The new value to set.</param>    procedure SetSkipSerialNoQtyValidation(NewSkipSerialNoQtyValidation: Boolean)    begin        SkipSerialNoQtyValidation := NewSkipSerialNoQtyValidation;    end;    local procedure CheckInvoicedQuantity(ItemLedgEntry: Record "Item Ledger Entry"; ValueEntry: Record "Value Entry"; var ModifyEntry: Boolean)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckInvoicedQuantity(ItemLedgEntry, ValueEntry, ModifyEntry, IsHandled);        if IsHandled then            exit;        if Abs(ItemLedgEntry."Invoiced Quantity") > Abs(ItemLedgEntry.Quantity) then            Error(Text030, ItemLedgEntry."Entry No.");        ModifyEntry := true;    end;    local procedure ShowFixedApplicationError()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeShowFixedApplicationError(IsHandled);        if IsHandled then            exit;        Error(Text027);    end;    [InherentPermissions(PermissionObjectType::TableData, Database::"Item Ledger Entry", 'r')]    [InherentPermissions(PermissionObjectType::TableData, Database::"Item Ledger Entry", 'r')]    [InherentPermissions(PermissionObjectType::TableData, Database::"Value Entry", 'r')]    local procedure ValidateSequenceNo(LedgEntryNo: Integer; xLedgEntryNo: Integer; TableNo: Integer)    var        SequenceNoMgt: Codeunit "Sequence No. Mgt.";    begin        if LedgEntryNo = xLedgEntryNo then            exit;        if InvtSetup.UseLegacyPosting() then            exit;        SequenceNoMgt.ValidateSeqNo(TableNo);    end;    /// <summary>    /// Marks the inbound item ledger entries that are applied to a specific outbound item ledger entry for adjustment.    /// </summary>    /// <param name="OutboundItemLedgerEntryNo">Outbound item ledger entry no.</param>    procedure MarkAppliedInboundItemEntriesForAdjustment(OutboundItemLedgerEntryNo: Integer)    var        InboundItemLedgerEntry: Record "Item Ledger Entry";        ItemApplicationEntry: Record "Item Application Entry";    begin        if ItemApplicationEntry.GetInboundEntriesTheOutbndEntryAppliedTo(OutboundItemLedgerEntryNo) then            repeat                InboundItemLedgerEntry.SetLoadFields("Applied Entry to Adjust");                InboundItemLedgerEntry.Get(ItemApplicationEntry."Inbound Item Entry No.");                InboundItemLedgerEntry.SetAppliedEntryToAdjust(true);            until ItemApplicationEntry.Next() = 0;    end;    local procedure CheckItemSerialNoForCorrILE(ItemJnlLine2: Record "Item Journal Line")    var        ItemLedgerEntry: Record "Item Ledger Entry";    begin        if SkipSerialNoQtyValidation then            exit;        ItemLedgerEntry.SetLoadFields(Quantity);        ItemLedgerEntry.SetRange("Item No.", ItemJnlLine2."Item No.");        ItemLedgerEntry.SetRange("Variant Code", ItemJnlLine2."Variant Code");        ItemLedgerEntry.SetTrackingFilterFromItemJournalLine(ItemJnlLine2);        ItemLedgerEntry.CalcSums(Quantity);        if ItemLedgerEntry.Quantity > 0 then            Error(Text014, ItemJnlLine2."Serial No.");    end;    local procedure GetExistingExpirationDateFromILE(var ItemTrackingSetup: Record "Item Tracking Setup"; var ExistingExpirationDate: Date; var SumOfEntries: Decimal)    begin        ItemTrackingSetup.CopyTrackingFromNewTrackingSpec(TempTrackingSpecification);        ExistingExpirationDate :=          ItemTrackingMgt.ExistingExpirationDateAndQty(            TempTrackingSpecification."Item No.", TempTrackingSpecification."Variant Code",            ItemTrackingSetup, SumOfEntries);        if ((ExistingExpirationDate = 0D) and (SumOfEntries = 0)) and           ((TempTrackingSpecification."New Lot No." = TempTrackingSpecification."Lot No.") and            (TempTrackingSpecification."New Package No." <> TempTrackingSpecification."Package No."))        then begin            ItemTrackingSetup.CopyTrackingFromTrackingSpec(TempTrackingSpecification);            ExistingExpirationDate := ItemTrackingMgt.ExistingExpirationDateAndQty(              TempTrackingSpecification."Item No.", TempTrackingSpecification."Variant Code",              ItemTrackingSetup, SumOfEntries);            if (ExistingExpirationDate = 0D) and (SumOfEntries > 0) then                SumOfEntries := 0;        end;    end;    local procedure CheckCostPerUnitInValueEntry(ItemJournalLine: Record "Item Journal Line"): Boolean    var        OldValueEntry: Record "Value Entry";    begin        if ItemJournalLine."Source Currency Code" = '' then            exit;        if not (ItemJournalLine."Document Type" in [ItemJournalLine."Document Type"::"Purchase Credit Memo", ItemJournalLine."Document Type"::"Purchase Return Shipment"]) then            exit;        OldValueEntry.SetLoadFields("Cost per Unit", "Valued Quantity", "Discount Amount");        OldValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type", "Item Ledger Entry Type");        OldValueEntry.ReadIsolation(IsolationLevel::ReadUncommitted);        OldValueEntry.SetRange("Item Ledger Entry No.", ItemJournalLine."Applies-to Entry");        OldValueEntry.SetRange("Entry Type", OldValueEntry."Entry Type"::"Direct Cost");        OldValueEntry.SetRange("Item Ledger Entry Type", OldValueEntry."Item Ledger Entry Type"::Purchase);        if OldValueEntry.FindFirst() then            exit(OldValueEntry."Cost per Unit" = ItemJournalLine."Unit Cost");        exit(false);    end;    local procedure SetCostAmountAndCostAmountFCYOnSameCostPerUnit(ItemJournalLine: Record "Item Journal Line"; var CostAmt: Decimal; var CostAmtACY: Decimal)    begin        if not CheckCostPerUnitInValueEntry(ItemJournalLine) then            exit;        CostAmt := ItemJnlLine.Amount;        CostAmtACY := ItemJnlLine."Amount (ACY)";    end;    local procedure CheckDropShipmentForSetupTempSplitItemJnlLine(ItemJournalLine: Record "Item Journal Line"): Boolean    begin        if (ItemJournalLine."Drop Shipment") then            if (ItemJournalLine."Document Type" = ItemJournalLine."Document Type"::"Purchase Receipt") and (ItemJournalLine.Quantity > 0) then                exit(false)            else                exit(true);        exit(false);    end;    local procedure ShouldUseCumulativeRoundingForExpectedCost(): Boolean    begin        if ItemJnlLine."Entry Type" <> ItemJnlLine."Entry Type"::Purchase then            exit(false);        if Item."Costing Method" = Item."Costing Method"::Standard then            exit(false);        if not (InvtSetup."Automatic Cost Posting") or not (InvtSetup."Expected Cost Posting to G/L") then            exit(false);        if Item."Cost is Adjusted" or Item."Allow Online Adjustment" or            (Item."Flushing Method" <> Item."Flushing Method"::Manual) then            exit(false);        exit(true);    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Sequence No. Mgt.", 'OnPreviewableLedgerEntry', '', false, false)]    local procedure OnPreviewableLedgerEntry(TableNo: Integer; var IsPreviewable: Boolean)    begin        if TableNo in [Database::"Item Ledger Entry", Database::"Item Register", Database::"Value Entry",                       Database::Microsoft.Manufacturing.Capacity."Capacity Ledger Entry", Database::"Phys. Inventory Ledger Entry",                       Database::"Item Application Entry", Database::"Item Application Entry History"]        then            IsPreviewable := true;    end;    internal procedure RestoreTempSplitItemJnlLine(var TempSplitItemJnlLineFrom: Record "Item Journal Line" temporary)    begin        TempSplitItemJnlLine.Reset();        TempSplitItemJnlLine.DeleteAll();        if TempSplitItemJnlLineFrom.FindSet() then            repeat                TempSplitItemJnlLine := TempSplitItemJnlLineFrom;                TempSplitItemJnlLine.Insert();            until TempSplitItemJnlLineFrom.Next() = 0;    end;    internal procedure SaveTempSplitItemJnlLine(var TempSplitItemJnlLineTo: Record "Item Journal Line" temporary)    begin        TempSplitItemJnlLine.Reset();        if TempSplitItemJnlLine.FindSet() then            repeat                TempSplitItemJnlLineTo := TempSplitItemJnlLine;                TempSplitItemJnlLineTo.Insert();            until TempSplitItemJnlLine.Next() = 0;    end;    internal procedure RestoreTempTrackingSpecification(var TempTrackingSpecificationFrom: Record "Tracking Specification" temporary)    begin        TempTrackingSpecification.Reset();        TempTrackingSpecification.DeleteAll();        if TempTrackingSpecificationFrom.FindSet() then            repeat                TempTrackingSpecification := TempTrackingSpecificationFrom;                TempTrackingSpecification.Insert();            until TempTrackingSpecificationFrom.Next() = 0;    end;    internal procedure SaveTempTrackingSpecification(var TempTrackingSpecificationTo: Record "Tracking Specification" temporary)    begin        TempTrackingSpecification.Reset();        if TempTrackingSpecification.FindSet() then            repeat                TempTrackingSpecificationTo := TempTrackingSpecification;                TempTrackingSpecificationTo.Insert();            until TempTrackingSpecification.Next() = 0;    end;    internal procedure GetItemLedgerEntryNo(): Integer    begin        exit(ItemLedgEntryNo);    end;    internal procedure RegisterWhseJnlLine(var WhseJnlLine: Record "Warehouse Journal Line")    begin        WhseJnlRegisterLine.RegisterWhseJnlLine(WhseJnlLine);    end;    internal procedure GetSkipRetrieveItemTracking(): Boolean    begin        exit(SkipRetrieveItemTracking);    end;    internal procedure SetSkipRetrieveItemTracking(NewSkipRetrieveItemTracking: Boolean)    begin        SkipRetrieveItemTracking := NewSkipRetrieveItemTracking;    end;    internal procedure SetGlobalItemTrackingCode(ItemTrackingCode: Record "Item Tracking Code")    begin        GlobalItemTrackingCode := ItemTrackingCode;    end;    internal procedure SetGlobalItemTrackingSetup(ItemTrackingSetup: Record "Item Tracking Setup")    begin        GlobalItemTrackingSetup := ItemTrackingSetup;    end;#if not CLEAN28    [Obsolete('This event is no longer used.', '28.0')]    [IntegrationEvent(false, false)]    local procedure OnVerifyInvoicedQtyOnAfterGetSalesShipmentHeader(ItemLedgEntry2: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnAfterGetAppliedFromValues(var ValueEntry: Record "Value Entry"; NegValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertPhysInventoryEntry(var PhysInventoryLedgerEntry: Record "Phys. Inventory Ledger Entry"; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertPostValueEntryToGL(ValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterIsPostToGL(ValueEntry: Record "Value Entry"; var Result: Boolean; PostToGL: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnAfterCheckItemTrackingOfComp(TempHandlingSpecification: Record "Tracking Specification"; ItemJnlLine: Record "Item Journal Line")    begin        OnAfterCheckItemTrackingOfComp(TempHandlingSpecification, ItemJnlLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterCheckItemTrackingOfComp(TempHandlingSpecification: Record "Tracking Specification"; ItemJnlLine: Record "Item Journal Line")    begin    end;#endif#if not CLEAN27    internal procedure RunOnBeforeGetOutputProdOrder(var ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin        OnBeforeGetOutputProdOrder(ProdOrder, ItemJnlLine, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeGetOutputProdOrder(var ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnBeforeGetOutputProdOrderLine(var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin        OnBeforeGetOutputProdOrderLine(ProdOrderLine, ItemJnlLine, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeGetOutputProdOrderLine(var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnBeforeGetProdOrderLine(var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; OrderNo: Code[20]; OrderLineNo: Integer; var IsHandled: Boolean)    begin        OnBeforeGetProdOrderLine(ProdOrderLine, OrderNo, OrderLineNo, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeGetProdOrderLine(var ProdOrderLine: Record Microsoft.Manufacturing.Document."Prod. Order Line"; OrderNo: Code[20]; OrderLineNo: Integer; var IsHandled: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnBeforeGetProdOrderRoutingLine(var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; OldItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin        OnBeforeGetProdOrderRoutingLine(ProdOrderRoutingLine, OldItemJnlLine, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeGetProdOrderRoutingLine(var ProdOrderRoutingLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; OldItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforeIsNotInternalWhseMovement(ItemJnlLine: Record "Item Journal Line"; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeIsInterimRevaluation(ItemJnlLine: Record "Item Journal Line"; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPostingDateWithExpirationDate(var ItemLedgEntry: Record "Item Ledger Entry"; ItemTrackingCode: Record "Item Tracking Code"; OldItemLedgEntry: Record "Item Ledger Entry"; var IsHandled: Boolean; var ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeItemValuePosting(ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnBeforePostOutput(var ItemJnlLine: Record "Item Journal Line")    begin        OnBeforePostOutput(ItemJnlLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforePostOutput(var ItemJnlLine: Record "Item Journal Line")    begin    end;#endif#if not CLEAN27    internal procedure RunOnBeforePostOutputUpdateProdOrderRtngLine(var ProdOrderRtngLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin        OnBeforePostOutputUpdateProdOrderRtngLine(ProdOrderRtngLine, ItemJnlLine, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforePostOutputUpdateProdOrderRtngLine(var ProdOrderRtngLine: Record Microsoft.Manufacturing.Document."Prod. Order Routing Line"; ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnCalcCapLedgerEntriesSetupRunTimeOnAfterCapLedgerEntrySetFilters(var CapLedgerEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; ItemJnlLine: Record "Item Journal Line")    begin        OnCalcCapLedgerEntriesSetupRunTimeOnAfterCapLedgerEntrySetFilters(CapLedgerEntry, ItemJnlLine);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnCalcCapLedgerEntriesSetupRunTimeOnAfterCapLedgerEntrySetFilters(var CapLedgerEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; ItemJnlLine: Record "Item Journal Line")    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnCheckExpirationDateOnAfterCalcSumLot(var SumLot: Decimal; SignFactor: Integer; var TempTrackingSpecification: Record "Tracking Specification" temporary; var SkipNewExpirationDateCheck: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckExpirationDateOnBeforeTestNewLotNo(var ItemJournalLine: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; ExistingExpirationDate: Date; SumOfEntries: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckExpirationDateOnBeforeAssignExpirationDate(var TempTrackingSpecification: Record "Tracking Specification" temporary; ExistingExpirationDate: Date; var IsHandled: Boolean; GlobalItemTrackingCode: Record "Item Tracking Code"; ItemJnlLine2: Record "Item Journal Line"; SignFactor: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSplitItemJnlLineOnBeforeInsertTempTrkgSpecification(var TempTrackingSpecification: Record "Tracking Specification" temporary; ItemJnlLine2: Record "Item Journal Line"; SignFactor: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitTransValueEntryOnBeforeCalcCostAmounts(GlobalValueEntry: Record "Value Entry"; var ValueEntry: Record "Value Entry"; ItemTrackingSetup: Record "Item Tracking Setup"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertValueEntryOnBeforeShouldCalcExpectedCost(var ItemJournalLine: Record "Item Journal Line"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntry: Record "Value Entry"; TransferItem: Boolean; var ShouldCalcExpectedCost: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertValueEntryOnBeforeCalcExpectedCost(var ItemJnlLine: Record "Item Journal Line"; var ItemLedgEntry: Record "Item Ledger Entry"; var ValueEntry: Record "Value Entry"; TransferItemPBln: Boolean; var InventoryPostingToGL: Codeunit "Inventory Posting To G/L"; var ShouldCalcExpectedCost: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertValueEntryOnBeforeRoundAmtValueEntry(var ValueEntry: Record "Value Entry"; var ItemLedgEntry: Record "Item Ledger Entry"; ItemJnlLine: Record "Item Journal Line"; TransferItem: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertVarValueEntryOnAfterInitValueEntryFields(var ValueEntry: record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertItemLedgEntryOnBeforeVerifyOnInventory(ItemJnlLine: Record "Item Journal Line"; ItemLedgEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertItemLedgEntryOnCheckItemTracking(ItemJnlLine: Record "Item Journal Line"; ItemLedgEntry: Record "Item Ledger Entry"; ItemTrackingCode: Record "Item Tracking Code"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertCapValueEntryOnAfterUpdateCapLedgEntry(var ValueEntry: Record "Value Entry"; ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertCapValueEntryOnAfterInsertValueEntryRelation(var ValueEntry: Record "Value Entry"; ItemJnlLine: Record "Item Journal Line"; var TempValueEntryRelation: Record "Value Entry Relation" temporary)    begin    end;    [InternalEvent(false)]    local procedure OnInsertCapValueEntryOnBeforeCapLedgEntryModify(var CapLedgEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemOnBeforeGetGlobalLedgerEntry(ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeRecalculateCostPerUnit(var ValueEntry: Record "Value Entry"; ItemJnlLine: Record "Item Journal Line"; var ItemLedgEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetCalledFromAdjustment(CalledFromAdjustment: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertTransferEntryOnBeforeInitTransValueEntry(var TempItemEntryRelation: Record "Item Entry Relation"; var NewItemLedgEntry: Record "Item Ledger Entry"; Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitCorrItemLedgEntryOnAfterRetrieveAppliedExpirationDate(var NewItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSplitItemJnlLineOnBeforePostItemJnlLine(var TempTrackingSpecification: Record "Tracking Specification"; var GlobalItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSplitItemJnlLineOnAfterDeleteTempSplitItemJnlLine(ItemJournalLine: Record "Item Journal Line"; CalledFromAdjustment: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertValueEntryOnAfterTempValueEntryRelationInsert(var ValueEntry: Record "Value Entry"; ItemJnlLine: Record "Item Journal Line"; var TempValueEntryRelation: Record "Value Entry Relation");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateUnitCostOnAfterAssignLastDirectCost(var ValueEntry: Record "Value Entry"; var Item: Record Item; LastDirectCost: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnItemQtyPostingOnAfterInsertApplEntry(var ItemJnlLine: Record "Item Journal Line"; var TempSplitItemJnlLine: Record "Item Journal Line" temporary; var GlobalItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnItemQtyPostingOnBeforeInsertApplEntry(var GlobalItemLedgEntry: Record "Item Ledger Entry"; ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnApplyOnBeforeInsertApplEntry(var ItemApplnEntry: Record "Item Application Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCostApplyOnBeforeInsertApplEntry(var GlobalItemLedgEntry: Record "Item Ledger Entry"; var ApplyWithItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnItemLedgEntryPositiveOnBeforeInsertApplEntry(var OldItemLedgEntry: Record "Item Ledger Entry"; var ItemLedgEntry: Record "Item Ledger Entry"; var GlobalItemLedgEntry: Record "Item Ledger Entry"; var AppliedQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertTransferEntryOnBeforeInsertApplEntry(var NewItemLedgEntry: Record "Item Ledger Entry"; var ItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertApplEntryOnBeforeModify(var ItemApplicationEntry: Record "Item Application Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnBeforeInitCorrItemLedgEntry(var ItemJnlLine: Record "Item Journal Line"; var OldItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnAfterInitCorrItemLedgEntry(var OldItemLedgEntry: Record "Item Ledger Entry"; var NewItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnAfterUpdateItemApplnEntry(var ItemJnlLine: Record "Item Journal Line"; OldItemLedgEntry: Record "Item Ledger Entry"; NewItemLedgEntry: Record "Item Ledger Entry"; NewValueEntry: Record "Value Entry"; InventoryPostingToGL: Codeunit "Inventory Posting To G/L")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnBeforeUpdateOldItemLedgEntry(var OldValueEntry2: Record "Value Entry"; var NewItemLedgEntry: Record "Item Ledger Entry"; var NewValueEntry: Record "Value Entry"; var ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnBeforeInsertApplEntry(var NewItemLedgEntry: Record "Item Ledger Entry"; var OldItemLedgEntry: Record "Item Ledger Entry"; var GlobalItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSetupSplitJnlLine(var ItemJnlLine2: Record "Item Journal Line"; var TempSplitItemJnlLine: Record "Item Journal Line"; var ItemJnlLineOrigin: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification"; TrackingSpecExists: Boolean; CalledFromAdjustment: Boolean; PostponeReservationHandling: Boolean; var PostItemJnlLine: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnBeforeFirstReservationSetFilters(var ItemJnlLine: Record "Item Journal Line"; var StartApplication: Boolean; FirstReservation: Boolean; var Handled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnBeforeCloseSurplusTrackingEntry(ItemJnlLine: Record "Item Journal Line"; var StartApplication: Boolean; var UseReservationApplication: Boolean; var Handled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertPhysInventoryEntry(var ItemJnlLineOrigin: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnItemValuePostingOnBeforeInsertOHValueEntry(var ItemJnlLine: Record "Item Journal Line"; var GlobalValueEntry: Record "Value Entry"; var GlobalItemLedgEntry: Record "Item Ledger Entry"; var ValueEntryNo: Integer; var IsHandled: Boolean; var VarianceAmount: Decimal; var VarianceAmountACY: Decimal; var OverheadAmount: Decimal; var OverheadAmountACY: Decimal; var VarianceRequired: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnPostConsumptionOnBeforeCalcRemQtyToPostThisLine(var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ItemJnlLine: Record "Item Journal Line"; var TempHandlingSpecification: Record "Tracking Specification"; RemQtyToPost: Decimal; UseItemTrackingApplication: Boolean; LastLoop: Boolean; var IsHandled: Boolean)    begin        OnPostConsumptionOnBeforeCalcRemQtyToPostThisLine(ProdOrderComp, ItemJnlLine, TempHandlingSpecification, RemQtyToPost, UseItemTrackingApplication, LastLoop, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostConsumptionOnBeforeCalcRemQtyToPostThisLine(var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ItemJnlLine: Record "Item Journal Line"; var TempHandlingSpecification: Record "Tracking Specification"; RemQtyToPost: Decimal; UseItemTrackingApplication: Boolean; LastLoop: Boolean; var IsHandled: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostConsumptionOnBeforeCalcRemainingQuantity(var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ItemJnlLine: Record "Item Journal Line"; var NewRemainingQty: Decimal; var QtyToPost: Decimal; var IsHandled: Boolean; var RemQtyToPost: Decimal)    begin        OnPostConsumptionOnBeforeCalcRemainingQuantity(ProdOrderComp, ItemJnlLine, NewRemainingQty, QtyToPost, IsHandled, RemQtyToPost);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostConsumptionOnBeforeCalcRemainingQuantity(var ProdOrderComp: Record Microsoft.Manufacturing.Document."Prod. Order Component"; var ItemJnlLine: Record "Item Journal Line"; var NewRemainingQty: Decimal; var QtyToPost: Decimal; var IsHandled: Boolean; var RemQtyToPost: Decimal)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostConsumptionOnRemQtyToPostOnBeforeInsertConsumpEntry(var ItemJnlLine: Record "Item Journal Line"; var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component")    begin        OnPostConsumptionOnRemQtyToPostOnBeforeInsertConsumpEntry(ItemJnlLine, ProdOrderComponent);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostConsumptionOnRemQtyToPostOnBeforeInsertConsumpEntry(var ItemJnlLine: Record "Item Journal Line"; var ProdOrderComponent: Record Microsoft.Manufacturing.Document."Prod. Order Component")    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnSetItemAdjmtPropertiesOnBeforeCheckModifyItem(var Item2: Record Item; var ModifyItem: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupTempSplitItemJnlLineOnAfterCalcPostItemJnlLine(var TempSplitItemJnlLine: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var PostItemJnlLine: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCodeOnBeforeCheckItemTracking(var ItemJnlLine: Record "Item Journal Line"; var DisableItemTracking: Boolean; var IsHandled: Boolean; var TempTrackingSpecification: Record "Tracking Specification"; var ItemTrackingSetup: Record "Item Tracking Setup")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckInvoicedQuantity(ItemLedgEntry: Record "Item Ledger Entry"; ValueEntry: Record "Value Entry"; var ModifyEntry: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateOrigAppliedFromEntryOnItemApplEntryLoop(var ItemLedgEntry: Record "Item Ledger Entry"; ItemApplEntry: Record "Item Application Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateItemLedgEntryOnBeforeUpdateOutboundItemLedgEntry(ValueEntry: Record "Value Entry"; var IsHandled: Boolean; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnApplicationLoop(var ItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemOnBeforeSetAverageTransfer(var ItemJnlLine: Record "Item Journal Line"; CalledFromAdjustment: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeTouchItemEntryCost(var ItemLedgerEntry: Record "Item Ledger Entry"; ItemJnlLine: Record "Item Journal Line"; IsAdjustment: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUnApply(var ItemApplnEntry: Record "Item Application Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetupSplitJnlLineProcedure(var ItemJnlLine2: Record "Item Journal Line"; TrackingSpecExists: Boolean; CalledFromAdjustment: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeShowFixedApplicationError(var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemOnBeforeTransferReservFromJobPlanningLine(var ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean; var AverageTransfer: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRunWithCheckOnAfterRetrieveItemTracking(var ItemJournalLine: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification"; var TrackingSpecExists: Boolean; PostponeReservationHandling: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckItemTrackingOnAfterCheckRequiredTrackingNos(ItemJournalLine: Record "Item Journal Line"; ItemTrackingSetup: Record "Item Tracking Setup"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertCapValueEntryOnBeforeInventoryPostingToGL(ValueEntry: Record "Value Entry"; var IsHandled: Boolean; PostToGL: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnBeforePostOutputForProdOrder(var ItemJnlLine: Record "Item Journal Line"; var LastOperation: Boolean; var IsHandled: Boolean)    begin        OnBeforePostOutputForProdOrder(ItemJnlLine, LastOperation, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforePostOutputForProdOrder(var ItemJnlLine: Record "Item Journal Line"; var LastOperation: Boolean; var IsHandled: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnPostItemOnAfterCheckCostingMethodStandard(var Item: Record Item; var ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostItemOnAfterSetItemJnlCostingMethodStandard(var Item: Record Item; var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateLinkedValuationDate(GlobalItemLedgEntry: Record "Item Ledger Entry"; FromItemledgEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostInventoryToGLOnAfterPostInvtBuffer(var ValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCodeOnBeforeTestOrder(ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostInvtBufferOnAfterBufferInvtPosting(var ValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCodeOnAfterCalcQtyPerUnitOfMeasure(var ItemJnlLine: Record "Item Journal Line"; Subcontracting: Boolean; var QtyPerUnitOfMeasure: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertValueEntryOnBeforeInsertPostValueEntryToGL(var ValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnItemQtyPostingOnAfterInsertTransferEntry(var ItemJnlLine: Record "Item Journal Line"; AverageTransfer: Boolean; GlobalItemLedgEntry: Record "Item Ledger Entry"; OldItemLedgEntry: Record "Item Ledger Entry"; TotalAppliedQty: Decimal; var TempItemEntryRelation: Record "Item Entry Relation"; var GlobalValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertValueEntryOnAfterInsertPostValueEntryToGL(var ValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateValuationDate(GlobalItemLedgEntry: Record "Item Ledger Entry"; FromItemLedgEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCodeOnBeforeSetQuantity(var ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckItemTrackingInformationOnBeforeTestFields(ItemTrackingSetup: Record "Item Tracking Setup"; TrackingSpecification: Record "Tracking Specification"; ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostInventoryToGLOnBeforePostInvtBuffer(var InventoryPostingToGL: Codeunit "Inventory Posting To G/L"; PostToGL: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertTransferEntryOnBeforeCalcIsReserved(ItemJnlLine: Record "Item Journal Line"; var TempTrackingSpecification: Record "Tracking Specification"; NewItemLedgEntry: Record "Item Ledger Entry"; ItemLedgEntry: Record "Item Ledger Entry"; var IsReserved: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnSetupTempSplitItemJnlLineOnBeforeCalcPostItemJnlLine(var TempSplitItemJnlLine: Record "Item Journal Line"; TempTrackingSpecification: Record "Tracking Specification")    begin    end;    [InternalEvent(false)]    local procedure OnSetupTempSplitItemJnlLineOnAfterDeductNonDistr(var TempSplitItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCodeOnBeforeRunCheck(var ItemJnlCheckLine: Codeunit "Item Jnl.-Check Line"; var ItemJnlLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnBeforeInsertCorrOldItemLedgEntry(OldItemLedgEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnBeforeReservationExists(ItemJnlLine: Record "Item Journal Line"; var Result: Boolean; var IsHandled: Boolean)    begin        OnBeforeReservationExists(ItemJnlLine, Result, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeReservationExists(ItemJnlLine: Record "Item Journal Line"; var Result: Boolean; var IsHandled: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnAfterCalcShouldInsertCorrValueEntry(OldItemLedgEntry: Record "Item Ledger Entry"; var ShouldInsertCorrValueEntries: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnPostOutputOnBeforeGetMfgAmounts(var ItemJnlLine: Record "Item Journal Line"; ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; var IsHandled: Boolean)    begin        OnPostOutputOnBeforeGetMfgAmounts(ItemJnlLine, ProdOrder, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputOnBeforeGetMfgAmounts(var ItemJnlLine: Record "Item Journal Line"; ProdOrder: Record Microsoft.Manufacturing.Document."Production Order"; var IsHandled: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnUpdateAvgCostAdjmtBufferOnAfterSetValueEntry(var ValueEntry: Record "Value Entry"; OldItemLedgEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetGeneralPostingSetup(ItemJournalLine: Record "Item Journal Line"; var GeneralPostingSetup: Record "General Posting Setup"; PostToGl: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckItemOnAfterGetItem(Item: Record Item; ItemJnlLine: Record "Item Journal Line"; CalledFromAdjustment: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckItemVariantOnAfterGetItemVariant(ItemVariant: Record "Item Variant"; ItemJnlLine: Record "Item Journal Line"; CalledFromAdjustment: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterMoveApplication(var ItemLedgerEntry: Record "Item Ledger Entry"; OldItemLedgerEntry: Record "Item Ledger Entry"; var Enough: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitValueEntryOnBeforeSetDocumentLineNo(ItemJournalLine: Record "Item Journal Line"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntry: Record "Value Entry")    begin    end;#if not CLEAN27    internal procedure RunOnCorrectOutputValuationDateOnBeforeValueEntryFindSet(var ValueEntry: Record "Value Entry")    begin        OnCorrectOutputValuationDateOnBeforeValueEntryFindSet(ValueEntry);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnCorrectOutputValuationDateOnBeforeValueEntryFindSet(var ValueEntry: Record "Value Entry")    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnAfterTestFirstApplyItemLedgEntry(OldItemLedgerEntry: Record "Item Ledger Entry"; var ItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnBeforeZeroRemainingQtyExit(var ItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertBalanceExpCostRevEntry(var GlobalItemLedgEntry: Record "Item Ledger Entry"; ValueEntry: Record "Value Entry"; var ValueEntryNo: Integer; var GLSetup: Record "General Ledger Setup"; var Currency: Record Currency; var GLSetupRead: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnAfterAutoTrack(var NewItemLedgEntry: Record "Item Ledger Entry"; var NewValueEntry: Record "Value Entry"; ItemJnlLine: Record "Item Journal Line"; Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitTransValueEntryOnBeforeCalcAdjustedCost(OldItemLedgEntry: Record "Item Ledger Entry"; var ValueEntry: Record "Value Entry"; var AdjCostInvoicedLCY: Decimal; var AdjCostInvoicedACY: Decimal; var DiscountAmount: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitTransValueEntryOnAfterCalcAdjustedCost(var ValueEntry: Record "Value Entry"; var GlobalValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetLastDirectCostValEntryOnBeforeFindDirCostValueEntry(var DirCostValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeFindNegValueEntry(var NegValueEntry: Record "Value Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnTestFirstApplyItemLedgEntryOnBeforeTestFields(var OldItemLedgerEntry: Record "Item Ledger Entry"; var ItemLedgerEntry: Record "Item Ledger Entry"; ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnTestFirstApplyItemLedgEntryOnBeforeReservationPreventsApplication(OldItemLedgerEntry: Record "Item Ledger Entry"; ItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterValuateAppliedAvgEntry(var ValueEntry: Record "Value Entry"; ItemJournalLine: Record "Item Journal Line");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnBeforeCheckPositive(var ItemJournalLine: Record "Item Journal Line"; var OldItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnBeforeAutoTrack(var NewItemLedgerEntry: Record "Item Ledger Entry");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCheckApplicationOnBeforeRemainingQtyError(OldItemLedgerEntry: Record "Item Ledger Entry"; ItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnAfterInsertItemReg(var ItemJournalLine: Record "Item Journal Line"; var OldItemLedgerEntry: Record "Item Ledger Entry"; var NewItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertCorrValueEntryOnAfterAssignNewValueEntry(GlobalItemLedgerEntry: Record "Item Ledger Entry"; var OldValueEntry: Record "Value Entry"; var NewValueEntry: Record "Value Entry"; var ItemJournalLine: Record "Item Journal Line"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntryNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeSetItemAdjmtProperties(ItemNo: Code[20]; ItemLedgEntryType: Enum "Item Ledger Entry Type"; Adjustment: Boolean; OriginalPostingDate: Date; ValuationDate: Date; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCheckItemAndItemVariant(ItemNo: Code[20]; VariantCode: Code[10]; var Item: Record Item; var ItemVariant: Record "Item Variant"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnItemValuePostingOnBeforeInsertValueEntry(ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnItemValuePostingOnBeforeUpdateItemApplnEntry(var ItemJournalLine: Record "Item Journal Line"; var ValueEntry: Record "Value Entry"; var ItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnItemValuePostingOnBeforeValuateAvgEntry(var ItemJournalLine: Record "Item Journal Line"; Item: Record Item; var ValueEntry: Record "Value Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateItemLedgerEntryOnAfterSetAppliedEntryToAdjust(ItemLedgerEntry: Record "Item Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateAvgCostAdjmtBuffer(var OldItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntry: Record "Value Entry"; var ValuationDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckItemAndVariant(var ItemJournalLine: Record "Item Journal Line"; CalledFromAdjustment: Boolean)    begin    end;#if not CLEAN27    internal procedure RunOnPostOutputOnBeforeInsertCostValueEntries(var ItemJournalLine: Record "Item Journal Line"; var CapacityLedgerEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; var ValuedQty: Decimal; var DirCostAmt: Decimal; var IndirCostAmt: Decimal)    begin        OnPostOutputOnBeforeInsertCostValueEntries(ItemJournalLine, CapacityLedgerEntry, ValuedQty, DirCostAmt, IndirCostAmt);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(true, false)]    local procedure OnPostOutputOnBeforeInsertCostValueEntries(var ItemJournalLine: Record "Item Journal Line"; var CapacityLedgerEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; var ValuedQty: Decimal; var DirCostAmt: Decimal; var IndirCostAmt: Decimal)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnUpdateItemApplnEntryOnAfterFilterItemApplicationEntry(var ItemApplnEntry: Record "Item Application Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnAfterSetLoadFieldsOnReservEntry(var ReservationEntry: Record "Reservation Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPublishPostingInventoryToGL(ItemJournalLine: Record "Item Journal Line"; var InventoryPostingToGL: Codeunit "Inventory Posting To G/L")    begin    end;#if not CLEAN27    internal procedure RunOnBeforeOnApplyCapNeed(var ItemJnlLine: Record "Item Journal Line"; var PostedSetupTime: Decimal; var PostedRunTime: Decimal; var IsHandled: Boolean)    begin        OnBeforeOnApplyCapNeed(ItemJnlLine, PostedSetupTime, PostedRunTime, IsHandled);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeOnApplyCapNeed(var ItemJnlLine: Record "Item Journal Line"; var PostedSetupTime: Decimal; var PostedRunTime: Decimal; var IsHandled: Boolean)    begin    end;#endif#if not CLEAN27    internal procedure RunOnPostOutputForProdOrderOnAfterApplyCapNeed(var ItemJnlLine: Record "Item Journal Line"; var ValuedQty: Decimal)    begin        OnPostOutputForProdOrderOnAfterApplyCapNeed(ItemJnlLine, ValuedQty);    end;    [Obsolete('Moved to codeunit MfgItemJnlPostLine', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnPostOutputForProdOrderOnAfterApplyCapNeed(var ItemJnlLine: Record "Item Journal Line"; var ValuedQty: Decimal)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforeReApply(ItemLedgerEntry: Record "Item Ledger Entry"; ApplyWith: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeRunPostWithReservation(var ItemJournalLine: Record "Item Journal Line"; var ReservationEntry: Record "Reservation Entry"; var ItemJournalLinePosted: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCollectItemEntryRelation(var TempItemEntryRelation: Record "Item Entry Relation" temporary; var TargetItemEntryRelation: Record "Item Entry Relation" temporary; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCollectValueEntryRelation(var TempValueEntryRelation: Record "Value Entry Relation" temporary; var TargetValueEntryRelation: Record "Value Entry Relation" temporary; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUndoValuePostingWithJob(OldItemLedgEntryNo: Integer; NewItemLedgEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeProcedureInsertCapLedgEntry(var ItemJournalLine: Record "Item Journal Line"; var CapacityLedgerEntry: Record Microsoft.Manufacturing.Capacity."Capacity Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCodeOnAfterRunCheck(var ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeItemQtyPosting(var ItemJnlLine: Record "Item Journal Line"; var CalledFromAdjustment: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetupTempSplitItemJnlLine(var ItemJnlLine2: Record "Item Journal Line"; var SignFactor: Integer; var NonDistrQuantity: Decimal; var NonDistrAmount: Decimal; var NonDistrAmountACY: Decimal; var NonDistrDiscountAmount: Decimal; var Invoice: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUndoQuantityPostingOnBeforeCheckItem(Item: Record Item; ItemLedgerEntry: Record "Item Ledger Entry"; var ShouldCheckItem: Boolean)    begin    end;    [InternalEvent(true)]    local procedure OnPostConsumption(        var ItemJnlLine: Record "Item Journal Line"; GlobalItemTrackingSetup: Record "Item Tracking Setup"; var TempSplitItemJnlLine: Record "Item Journal Line" temporary; var ProdOrderCompModified: Boolean; ItemLedgEntryNo: Integer)    begin    end;    [InternalEvent(true)]    local procedure OnPostOutput(        var ItemJnlLine: Record "Item Journal Line"; GlobalItemTrackingSetup: Record "Item Tracking Setup"; GlobalItemTrackingCode: Record "Item Tracking Code"; var GlobalItemLedgerEntry: Record "Item Ledger Entry"; var LastOperation: Boolean)    begin    end;    [InternalEvent(false)]    local procedure OnSetOrderAdjmtPropertiesForProduction(var InventoryAdjmtEntryOrder: Record "Inventory Adjmt. Entry (Order)"; OrderNo: Code[20]; OrderLineNo: Integer)    begin    end;    [InternalEvent(true)]    local procedure OnCorrectOutputValuationDateOnCheckProduction(ItemLedgerEntry: Record "Item Ledger Entry"; var TempValueEntry: Record "Value Entry" temporary; var ValuationDate: Date; var ShouldExit: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetUpdatedAppliedQtyForConsumption(OldItemLedgerEntry: Record "Item Ledger Entry"; ItemLedgerEntry: Record "Item Ledger Entry"; ReservationEntry2: Record "Reservation Entry"; SourceType: Integer; var AppliedQty: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnReApplyOnBeforeUpdateLinkedValuationDate(var ValueEntry: Record "Value Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyItemLedgEntryOnBeforeGetValuationDate(var ValueEntry: Record "Value Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateItemLedgEntryOnBeforeUpdateAvgCostAdjmtBuffer(ItemLedgerEntry: Record "Item Ledger Entry"; ValuationDate: Date; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetValuationDate(OldItemLedgerEntry: Record "Item Ledger Entry"; OldValuationDate: Date; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertVarValueEntryOnBeforeInsertValueEntry(var ValueEntry: Record "Value Entry"; var GlobalItemLedgerEntry: Record "Item Ledger Entry"; var IsHandled: Boolean; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertTransferEntryOnBeforeInsertValueEntry(var NewValueEntry: Record "Value Entry"; var NewItemLedgerEntry: Record "Item Ledger Entry"; var ValueEntryNo: Integer; var IsHandled: Boolean; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertCorrValueEntryOnBeforeInsert(var NewValueEntry: Record "Value Entry"; var ItemLedgerEntry: Record "Item Ledger Entry"; var ShouldInsertValueEntry: Boolean; ItemJournalLine: Record "Item Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcCostPerUnitForPositiveValuedQty(var ItemJournalLine: Record "Item Journal Line"; var ValueEntry: Record "Value Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcCostPerUnitForPositiveValuedQtyOnBeforeCheckShouldCalculateCostPerUnit(ValueEntry: Record "Value Entry"; ItemJournalLine: Record "Item Journal Line"; var ShouldCalculateCostPerUnit: Boolean)    begin    end;}