Codeunit 132200 Library - Costing

Application Test Library

src/Layers/W1/Tests/ApplicationTestLibrary/LibraryCosting.Codeunit.al659 lines, Copyright (c) Microsoft Corporation. MIT

/// <summary>/// Provides utility functions for inventory costing operations in test scenarios, including cost adjustment, posting, and validation./// </summary>codeunit 132200 "Library - Costing"{    trigger OnRun()    begin    end;    var        Assert: Codeunit Assert;        LibraryERM: Codeunit "Library - ERM";        IncorrectCostTxt: Label 'Incorrect Cost Amount in Entry No. %1.';        IncorrectRoundingTxt: Label 'Rounding mismatch of %1 for Inbound Entry No. %2.';        ShouldBeOfRecordTypeErr: Label 'Applies-To should be of type Record.';        WrongRecordTypeErr: Label 'Wrong Record Type.';    procedure AdjustCostItemEntries(ItemNoFilter: Text[250]; ItemCategoryFilter: Text[250])    var        AdjustCostItemEntriesReport: Report "Adjust Cost - Item Entries";    begin        Commit();        AdjustCostItemEntriesReport.InitializeRequest(ItemNoFilter, ItemCategoryFilter);        AdjustCostItemEntriesReport.UseRequestPage(false);        AdjustCostItemEntriesReport.RunModal();    end;    local procedure CalculateApplUnitCost(ItemLedgerEntryNo: Integer; PostingDate: Date; FirstOutboundValuePostingDate: Date; FirstOutboundValueEntryNo: Integer): Decimal    var        ValueEntry: Record "Value Entry";        CostWithoutRevaluation: Decimal;        ILEQuantity: Decimal;        RevaluationUnitCost: Decimal;    begin        ValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type");        ValueEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntryNo);        ValueEntry.SetRange("Valuation Date", 0D, PostingDate);        if ValueEntry.FindSet() then            repeat                if ValueEntry."Entry Type" = ValueEntry."Entry Type"::Revaluation then begin                    if (FirstOutboundValueEntryNo > ValueEntry."Entry No.") or (FirstOutboundValuePostingDate > ValueEntry."Posting Date") then                        RevaluationUnitCost +=                          (ValueEntry."Cost Amount (Actual)" + ValueEntry."Cost Amount (Expected)") / ValueEntry."Valued Quantity";                end else begin                    CostWithoutRevaluation += ValueEntry."Cost Amount (Actual)" + ValueEntry."Cost Amount (Expected)";                    ILEQuantity += ValueEntry."Item Ledger Entry Quantity";                end;            until ValueEntry.Next() = 0;        exit(CostWithoutRevaluation / ILEQuantity + RevaluationUnitCost);    end;    local procedure CalculateCostAmount(var ItemApplicationEntry: Record "Item Application Entry"; var TempItemJournalBuffer: Record "Item Journal Buffer" temporary; OutbndComplInvoiced: Boolean): Decimal    var        ItemLedgerEntry: Record "Item Ledger Entry";        RefCostAmount: Decimal;        RefInbILECostAmount: Decimal;        ValuationDate: Date;        FirstValuePostingDate: Date;        FirstValueEntryNo: Integer;    begin        if ItemApplicationEntry.FindSet() then begin            ValuationDate := FindLastValuationDate(ItemApplicationEntry."Outbound Item Entry No.");            FindFirstValueEntry(ItemApplicationEntry."Outbound Item Entry No.", FirstValueEntryNo, FirstValuePostingDate);            repeat                // Get the inbound Item Ledger Entry located at the other end of the application.                if ItemLedgerEntry.Get(ItemApplicationEntry."Inbound Item Entry No.") then begin                    // Add cost according to how much of the inbound ILE quantity was applied to the outbound ILE.                    RefInbILECostAmount :=                      RoundAmount(                        CalculateApplUnitCost(ItemLedgerEntry."Entry No.", ValuationDate, FirstValuePostingDate, FirstValueEntryNo) *                        ItemApplicationEntry.Quantity);                    RefCostAmount += RefInbILECostAmount;                    if OutbndComplInvoiced then                        UpdateBufferforRoundingCheck(                          TempItemJournalBuffer, ItemLedgerEntry."Entry No.", ItemApplicationEntry.Quantity, RefInbILECostAmount);                end;            until ItemApplicationEntry.Next() = 0;        end;        exit(RefCostAmount);    end;    procedure CalculateInventoryValue(var ItemJournalLine: Record "Item Journal Line"; var Item: Record Item; NewPostingDate: Date; NewDocNo: Code[20]; NewCalculatePer: Enum "Inventory Value Calc. Per"; NewByLocation: Boolean; NewByVariant: Boolean; NewUpdStdCost: Boolean; NewCalcBase: Enum "Inventory Value Calc. Base"; NewShowDialog: Boolean)    var        CalculateInventoryValueReport: Report "Calculate Inventory Value";    begin        CalculateInventoryValueReport.SetParameters(          NewPostingDate, NewDocNo, true, NewCalculatePer, NewByLocation, NewByVariant, NewUpdStdCost, NewCalcBase, NewShowDialog);        Commit();        CalculateInventoryValueReport.UseRequestPage(false);        CalculateInventoryValueReport.SetItemJnlLine(ItemJournalLine);        CalculateInventoryValueReport.SetTableView(Item);        CalculateInventoryValueReport.RunModal();    end;    procedure CopyStandardCostWorksheet(FromStandardCostWorksheetName: Code[10]; ToStandardCostWorksheetName: Code[10])    var        CopyStandardCostWorksheetReport: Report "Copy Standard Cost Worksheet";    begin        Clear(CopyStandardCostWorksheetReport);        CopyStandardCostWorksheetReport.Initialize(FromStandardCostWorksheetName, ToStandardCostWorksheetName, true);        CopyStandardCostWorksheetReport.UseRequestPage(false);        CopyStandardCostWorksheetReport.Run();    end;    procedure CheckAdjustment(Item: Record Item)    var        TempItemJournalBuffer: Record "Item Journal Buffer" temporary;    begin        PrepareBufferforRoundingCheck(Item, TempItemJournalBuffer);        if Item."Costing Method" = Item."Costing Method"::Average then            CheckAverageCosting(Item, TempItemJournalBuffer)        else            CheckNonAverageCosting(Item, TempItemJournalBuffer);        VerifyInboundEntriesRounding(TempItemJournalBuffer);    end;    local procedure CheckAverageCosting(Item: Record Item; var TempItemJournalBuffer: Record "Item Journal Buffer" temporary)    var        AvgCostAdjmtEntryPoint: Record "Avg. Cost Adjmt. Entry Point";        ValueEntry: Record "Value Entry";        OutboundItemLedgerEntry: Record "Item Ledger Entry";        FixedAppItemLedgerEntry: Record "Item Ledger Entry";        OutboundValueEntry: Record "Value Entry";        FixedAppValueEntry: Record "Value Entry";        TempValueEntry: Record "Value Entry" temporary;        CurrPeriodInboundCost: Decimal;        CurrPeriodInboundQty: Decimal;        PrevPeriodCost: Decimal;        PrevPeriodQty: Decimal;        RefCostAmount: Decimal;        OutboundCostAmount: Decimal;        RevaluationUnitCost: Decimal;        RefCostAmountwoReval: Decimal;        PeriodStartDate: Date;    begin        PrevPeriodCost := 0;        PrevPeriodQty := 0;        PeriodStartDate := 0D;        AvgCostAdjmtEntryPoint.SetRange("Item No.", Item."No.");        AvgCostAdjmtEntryPoint.FindSet();        ValueEntry.SetCurrentKey("Item No.", "Valuation Date", "Location Code", "Variant Code");        ValueEntry.SetRange("Item No.", Item."No.");        repeat            // Add cost and quantity of all inbound non-revaluation entries for the period            ValueEntry.SetRange("Valuation Date", PeriodStartDate, AvgCostAdjmtEntryPoint."Valuation Date");            ValueEntry.SetFilter("Valued Quantity", '>%1', 0);            ValueEntry.SetFilter("Entry Type", '<>%1', ValueEntry."Entry Type"::Revaluation);            ValueEntry.CalcSums("Cost Amount (Actual)", "Cost Amount (Expected)", "Item Ledger Entry Quantity");            CurrPeriodInboundCost := ValueEntry."Cost Amount (Actual)" + ValueEntry."Cost Amount (Expected)";            CurrPeriodInboundQty := ValueEntry."Item Ledger Entry Quantity";            // Reduce cost and quantity of inbound entries in the period, which are fixed applied            if ValueEntry.FindSet() then                repeat                    // Only loop through the quantity entries and add up the cost without revaluation                    if ValueEntry."Item Ledger Entry Quantity" <> 0 then begin                        FixedAppItemLedgerEntry.SetRange("Item No.", Item."No.");                        FixedAppItemLedgerEntry.SetRange("Applies-to Entry", ValueEntry."Item Ledger Entry No.");                        if FixedAppItemLedgerEntry.FindFirst() then begin                            FixedAppItemLedgerEntry.CalcSums(Quantity);                            FixedAppValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type");                            FixedAppValueEntry.SetRange("Item Ledger Entry No.", ValueEntry."Item Ledger Entry No.");                            FixedAppValueEntry.SetFilter("Entry Type", '<>%1', FixedAppValueEntry."Entry Type"::Revaluation);                            FixedAppValueEntry.SetRange("Valuation Date", PeriodStartDate, AvgCostAdjmtEntryPoint."Valuation Date");                            FixedAppValueEntry.SetFilter("Valued Quantity", '>%1', 0);                            FixedAppValueEntry.CalcSums("Cost Amount (Actual)", "Cost Amount (Expected)", "Item Ledger Entry Quantity");                            CurrPeriodInboundCost +=                              Round((FixedAppValueEntry."Cost Amount (Expected)" + FixedAppValueEntry."Cost Amount (Actual)") /                                FixedAppValueEntry."Item Ledger Entry Quantity" * FixedAppItemLedgerEntry.Quantity,                                LibraryERM.GetAmountRoundingPrecision());                            CurrPeriodInboundQty += FixedAppItemLedgerEntry.Quantity;                        end;                    end;                until ValueEntry.Next() = 0;            // Store the revaluation entries            ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::Revaluation);            TempValueEntry.DeleteAll();            if ValueEntry.FindSet() then                repeat                    TempValueEntry := ValueEntry;                    TempValueEntry.Insert();                until ValueEntry.Next() = 0;            // Add cost and quantity from previous period            CurrPeriodInboundCost += PrevPeriodCost;            CurrPeriodInboundQty += PrevPeriodQty;            // Validate Outbound entries for the period            OutboundValueEntry.SetRange("Item No.", Item."No.");            OutboundValueEntry.SetRange("Valuation Date", PeriodStartDate, AvgCostAdjmtEntryPoint."Valuation Date");            OutboundValueEntry.SetFilter("Item Ledger Entry Quantity", '<%1', 0);            if OutboundValueEntry.FindSet() then                repeat                    OutboundItemLedgerEntry.Get(OutboundValueEntry."Item Ledger Entry No.");                    if OutboundItemLedgerEntry."Applies-to Entry" = 0 then begin                        // If not fixed applied, unit cost should be equal to average cost for the period                        // Add applied revaluation                        RevaluationUnitCost := 0;                        if TempValueEntry.FindSet() then                            repeat                                if (OutboundValueEntry."Entry No." > TempValueEntry."Entry No.") or                                   (OutboundValueEntry."Posting Date" > TempValueEntry."Posting Date")                                then                                    RevaluationUnitCost +=                                      (TempValueEntry."Cost Amount (Actual)" + TempValueEntry."Cost Amount (Expected)") /                                      TempValueEntry."Valued Quantity";                            until TempValueEntry.Next() = 0;                        RefCostAmountwoReval := (CurrPeriodInboundCost / CurrPeriodInboundQty) * OutboundItemLedgerEntry.Quantity;                        RefCostAmount :=                          Round(                            RevaluationUnitCost * OutboundItemLedgerEntry.Quantity + RefCostAmountwoReval, LibraryERM.GetAmountRoundingPrecision());                        OutboundItemLedgerEntry.CalcFields("Cost Amount (Expected)", "Cost Amount (Actual)");                        OutboundCostAmount := OutboundItemLedgerEntry."Cost Amount (Expected)" + OutboundItemLedgerEntry."Cost Amount (Actual)";                        // Reduce the inbound cost and quantity for validating with the next outboud ILE                        CurrPeriodInboundCost += Round(RefCostAmountwoReval, LibraryERM.GetAmountRoundingPrecision());                        CurrPeriodInboundQty += OutboundItemLedgerEntry.Quantity;                        Assert.AreNearlyEqual(RefCostAmount, OutboundCostAmount, LibraryERM.GetAmountRoundingPrecision(),                          StrSubstNo(IncorrectCostTxt, OutboundItemLedgerEntry."Entry No."));                    end else begin                        // If fixed applied, verification is same as non-average cost items                        FixedAppItemLedgerEntry.Get(OutboundItemLedgerEntry."Entry No.");                        FixedAppItemLedgerEntry.SetRecFilter();                        CheckCostAmount(FixedAppItemLedgerEntry, TempItemJournalBuffer);                    end;                until OutboundValueEntry.Next() = 0;            // Prepare carry forward values for the next period            PeriodStartDate := AvgCostAdjmtEntryPoint."Valuation Date" + 1;            ValueEntry.SetRange("Valued Quantity");            ValueEntry.SetRange("Entry Type");            ValueEntry.CalcSums("Cost Amount (Actual)", "Cost Amount (Expected)", "Item Ledger Entry Quantity");            PrevPeriodCost += ValueEntry."Cost Amount (Actual)" + ValueEntry."Cost Amount (Expected)";            PrevPeriodQty += ValueEntry."Item Ledger Entry Quantity";        until AvgCostAdjmtEntryPoint.Next() = 0;    end;    local procedure CheckCostAmount(var ItemLedgerEntry: Record "Item Ledger Entry"; var TempItemJournalBuffer: Record "Item Journal Buffer" temporary)    var        ItemApplicationEntry: Record "Item Application Entry";        RefCostAmount: Decimal;    begin        if ItemLedgerEntry.FindSet() then            repeat                // Find all applications pointing to the ILE.                ItemApplicationEntry.SetRange("Outbound Item Entry No.", ItemLedgerEntry."Entry No.");                ItemApplicationEntry.SetFilter(Quantity, '<%1', 0);                // Calculate the reference cost amount on the ValuationDate                RefCostAmount := CalculateCostAmount(ItemApplicationEntry, TempItemJournalBuffer, ItemLedgerEntry."Completely Invoiced");                // Compare to actuals.                ItemLedgerEntry.CalcFields("Cost Amount (Expected)", "Cost Amount (Actual)");                Assert.AreEqual(                  RefCostAmount, ItemLedgerEntry."Cost Amount (Actual)" + ItemLedgerEntry."Cost Amount (Expected)",                  StrSubstNo(IncorrectCostTxt, ItemLedgerEntry."Entry No."));            until ItemLedgerEntry.Next() = 0;    end;    local procedure CheckNonAverageCosting(Item: Record Item; var TempItemJournalBuffer: Record "Item Journal Buffer" temporary)    var        ItemLedgerEntry: Record "Item Ledger Entry";    begin        // Check all outbound ILEs.        ItemLedgerEntry.Reset();        ItemLedgerEntry.SetRange("Item No.", Item."No.");        ItemLedgerEntry.SetRange(Positive, false);        CheckCostAmount(ItemLedgerEntry, TempItemJournalBuffer);    end;    procedure CheckInboundEntriesCost(var TempItemLedgerEntry: Record "Item Ledger Entry" temporary)    var        RefCostPerUnit: Decimal;        RefCost: Decimal;        ActualCost: Decimal;    begin        TempItemLedgerEntry.FindFirst();        TempItemLedgerEntry.CalcFields("Cost Amount (Expected)", "Cost Amount (Actual)");        RefCostPerUnit :=          (TempItemLedgerEntry."Cost Amount (Expected)" + TempItemLedgerEntry."Cost Amount (Actual)") / TempItemLedgerEntry.Quantity;        // Check if the subsequent inbound entries have the same cost as the original inbound entry - to make sure the cost modification has been propagated        while TempItemLedgerEntry.Next() <> 0 do begin            TempItemLedgerEntry.CalcFields("Cost Amount (Expected)", "Cost Amount (Actual)");            ActualCost := TempItemLedgerEntry."Cost Amount (Expected)" + TempItemLedgerEntry."Cost Amount (Actual)";            RefCost := Round(RefCostPerUnit * TempItemLedgerEntry.Quantity, LibraryERM.GetAmountRoundingPrecision());            Assert.AreEqual(RefCost, ActualCost, StrSubstNo(IncorrectCostTxt, TempItemLedgerEntry."Entry No."));        end;    end;#if not CLEAN27#pragma warning disable AL0801    [Obsolete('Moved to codeunit LibraryManufacturing', '27.0')]    procedure CheckProductionOrderCost(ProdOrder: Record "Production Order"; VerifyVarianceinOutput: Boolean)    var        LibraryManufacturing: Codeunit "Library - Manufacturing";    begin        LibraryManufacturing.CheckProductionOrderCost(ProdOrder, VerifyVarianceinOutput);    end;#pragma warning restore AL0801#endif    procedure CreatePurchasePrice(var PurchasePrice: Record "Purchase Price"; VendorNo: Code[20]; ItemNo: Code[20]; StartingDate: Date; CurrencyCode: Code[10]; VariantCode: Code[10]; UnitOfMeasureCode: Code[10]; MinimumQuantity: Decimal)    begin        PurchasePrice.Init();        PurchasePrice.Validate("Vendor No.", VendorNo);        PurchasePrice.Validate("Item No.", ItemNo);        PurchasePrice.Validate("Starting Date", StartingDate);        PurchasePrice.Validate("Currency Code", CurrencyCode);        PurchasePrice.Validate("Variant Code", VariantCode);        PurchasePrice.Validate("Unit of Measure Code", UnitOfMeasureCode);        PurchasePrice.Validate("Minimum Quantity", MinimumQuantity);        PurchasePrice.Insert(true);    end;    procedure CreateRevaluationJournal(var ItemJournalBatch: Record "Item Journal Batch"; var Item: Record Item; NewPostingDate: Date; NewDocNo: Code[20]; NewCalculatePer: Enum "Inventory Value Calc. Per"; NewByLocation: Boolean; NewByVariant: Boolean; NewUpdStdCost: Boolean; NewCalcBase: Enum "Inventory Value Calc. Base"; NewShowDialog: Boolean)    var        ItemJournalLine: Record "Item Journal Line";    begin        ItemJournalLine.Validate("Journal Template Name", ItemJournalBatch."Journal Template Name");        ItemJournalLine.Validate("Journal Batch Name", ItemJournalBatch.Name);        CalculateInventoryValue(          ItemJournalLine, Item, NewPostingDate, NewDocNo, NewCalculatePer, NewByLocation,          NewByVariant, NewUpdStdCost, NewCalcBase, NewShowDialog);    end;    procedure CreateRevaluationJnlLines(var Item: Record Item; ItemJournalLine: Record "Item Journal Line"; DocNo: Code[20]; CalculatePer: Enum "Inventory Value Calc. Per"; ReCalcStdCost: Enum "Inventory Value Calc. Base"; ByLocation: Boolean; ByVariant: Boolean; UpdStdCost: Boolean; PostingDate: Date)    var        TmpItem: Record Item;        CalcInvtValue: Report "Calculate Inventory Value";    begin        ItemJournalLine.DeleteAll();        CalcInvtValue.SetItemJnlLine(ItemJournalLine);        if Item.HasFilter then            TmpItem.CopyFilters(Item)        else begin            Item.Get(Item."No.");            TmpItem.SetRange("No.", Item."No.");        end;        CalcInvtValue.SetTableView(TmpItem);        CalcInvtValue.SetParameters(PostingDate, DocNo, true, CalculatePer, ByLocation, ByVariant, UpdStdCost, ReCalcStdCost, true);        CalcInvtValue.UseRequestPage(false);        CalcInvtValue.RunModal();    end;    procedure CreateSalesPrice(var SalesPrice: Record "Sales Price"; SalesType: Enum "Sales Price Type"; SalesCode: Code[20]; ItemNo: Code[20]; StartingDate: Date; CurrencyCode: Code[10]; VariantCode: Code[10]; UnitOfMeasureCode: Code[10]; MinimumQuantity: Decimal)    begin        SalesPrice.Init();        SalesPrice.Validate("Sales Type", SalesType);        SalesPrice.Validate("Sales Code", SalesCode);        SalesPrice.Validate("Item No.", ItemNo);        SalesPrice.Validate("Starting Date", StartingDate);        SalesPrice.Validate("Currency Code", CurrencyCode);        SalesPrice.Validate("Variant Code", VariantCode);        SalesPrice.Validate("Unit of Measure Code", UnitOfMeasureCode);        SalesPrice.Validate("Minimum Quantity", MinimumQuantity);        SalesPrice.Insert(true);    end;    procedure ImplementPriceChange(SalesPriceWorksheet: Record "Sales Price Worksheet")    var        ImplementPriceChangeReport: Report "Implement Price Change";    begin        Clear(ImplementPriceChangeReport);        ImplementPriceChangeReport.InitializeRequest(true);        ImplementPriceChangeReport.UseRequestPage(false);        ImplementPriceChangeReport.SetTableView(SalesPriceWorksheet);        ImplementPriceChangeReport.RunModal();    end;    local procedure FindFirstValueEntry(ItemLedgerEntryNo: Integer; var FirstEntryNo: Integer; var FirstPostingDate: Date)    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type");        ValueEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntryNo);        ValueEntry.FindSet();        repeat            if (ValueEntry."Item Ledger Entry Quantity" <> 0) and               ((FirstEntryNo = 0) or (FirstEntryNo > ValueEntry."Entry No."))            then begin                FirstEntryNo := ValueEntry."Entry No.";                FirstPostingDate := ValueEntry."Posting Date";            end;        until (ValueEntry.Next() = 0);    end;    local procedure FindLastValuationDate(ItemLedgerEntryNo: Integer) LastValuationDate: Date    var        ValueEntry: Record "Value Entry";    begin        ValueEntry.SetCurrentKey("Item Ledger Entry No.", "Entry Type");        ValueEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntryNo);        ValueEntry.FindSet();        repeat            if LastValuationDate < ValueEntry."Valuation Date" then                LastValuationDate := ValueEntry."Valuation Date";        until (ValueEntry.Next() = 0);        exit(LastValuationDate);    end;    procedure PostInvtCostToGLTest(PostMethod: Option; ItemNo: Code[20]; DocumentNo: Code[20]; ShowDim: Boolean; ShowOnlyWarnings: Boolean)    var        PostValueEntryToGL: Record "Post Value Entry to G/L";        PostInvtCostToGLTestReport: Report "Post Invt. Cost to G/L - Test";    begin        Commit();        PostValueEntryToGL.SetRange("Item No.", ItemNo);        PostInvtCostToGLTestReport.InitializeRequest(PostMethod, DocumentNo, ShowDim, ShowOnlyWarnings);        PostInvtCostToGLTestReport.SetTableView(PostValueEntryToGL);        PostInvtCostToGLTestReport.UseRequestPage(false);    end;    local procedure PrepareBufferforRoundingCheck(Item: Record Item; var TempItemJnlBuffer: Record "Item Journal Buffer" temporary)    var        InboundItemLedgerEntry: Record "Item Ledger Entry";    begin        // Create a buffer entry for each inbound entry - only consider invoiced quantity and cost        // Note: Rounding entries are created only after inbound and outbound entries have been invoiced completely        TempItemJnlBuffer.DeleteAll();        InboundItemLedgerEntry.SetRange("Item No.", Item."No.");        InboundItemLedgerEntry.SetRange(Positive, true);        InboundItemLedgerEntry.SetRange("Completely Invoiced", true);        if InboundItemLedgerEntry.FindSet() then            repeat                TempItemJnlBuffer.Init();                TempItemJnlBuffer."Line No." := InboundItemLedgerEntry."Entry No.";                TempItemJnlBuffer.Quantity := InboundItemLedgerEntry."Invoiced Quantity";                InboundItemLedgerEntry.CalcFields("Cost Amount (Actual)");                TempItemJnlBuffer."Inventory Value (Calculated)" := InboundItemLedgerEntry."Cost Amount (Actual)";                TempItemJnlBuffer.Insert();            until InboundItemLedgerEntry.Next() = 0;    end;    local procedure RoundAmount(Amount: Decimal): Decimal    begin        exit(Round(Amount, LibraryERM.GetAmountRoundingPrecision(), '='));    end;#if not CLEAN27#pragma warning disable AL0801    [Obsolete('Moved to codeunit LibraryManufacturing', '27.0')]    procedure SuggestCapacityStandardCost(var WorkCenter: Record "Work Center"; var MachineCenter: Record "Machine Center"; StandardCostWorksheetName: Code[10]; StandardCostAdjustmentFactor: Integer; StandardCostRoundingMethod: Code[10])    var        LibraryManufacturing: Codeunit "Library - Manufacturing";    begin        LibraryManufacturing.SuggestCapacityStandardCost(WorkCenter, MachineCenter, StandardCostWorksheetName, StandardCostAdjustmentFactor, StandardCostRoundingMethod);    end;#pragma warning restore AL0801#endif    procedure SuggestSalesPriceWorksheet(Item: Record Item; SalesCode: Code[20]; SalesType: Enum "Sales Price Type"; PriceLowerLimit: Decimal; UnitPriceFactor: Decimal)    var        SalesPrice: Record "Sales Price";        SuggestSalesPriceOnWksh: Report "Suggest Sales Price on Wksh.";    begin        Clear(SuggestSalesPriceOnWksh);        SuggestSalesPriceOnWksh.InitializeRequest2(          SalesType.AsInteger(), SalesCode, WorkDate(), WorkDate(), '', Item."Base Unit of Measure", false, PriceLowerLimit, UnitPriceFactor, '');        SuggestSalesPriceOnWksh.UseRequestPage(false);        SalesPrice.SetRange("Item No.", Item."No.");        SuggestSalesPriceOnWksh.SetTableView(SalesPrice);        SuggestSalesPriceOnWksh.RunModal();    end;    procedure SuggestItemPriceWorksheet(Item: Record Item; SalesCode: Code[20]; SalesType: Enum "Sales Price Type"; PriceLowerLimit: Decimal; UnitPriceFactor: Decimal)    var        SuggestItemPriceOnWksh: Report "Suggest Item Price on Wksh.";    begin        Clear(SuggestItemPriceOnWksh);        SuggestItemPriceOnWksh.InitializeRequest2(          SalesType.AsInteger(), SalesCode, WorkDate(), WorkDate(), '', Item."Base Unit of Measure", PriceLowerLimit, UnitPriceFactor, '', true);        SuggestItemPriceOnWksh.UseRequestPage(false);        Item.SetRange("No.", Item."No.");        SuggestItemPriceOnWksh.SetTableView(Item);        SuggestItemPriceOnWksh.RunModal();    end;    procedure SuggestItemPriceWorksheet2(Item: Record Item; SalesCode: Code[20]; SalesType: Enum "Sales Price Type"; PriceLowerLimit: Decimal; UnitPriceFactor: Decimal; CurrencyCode: Code[10])    var        TmpItem: Record Item;        SuggestItemPriceOnWksh: Report "Suggest Item Price on Wksh.";    begin        Clear(SuggestItemPriceOnWksh);        SuggestItemPriceOnWksh.InitializeRequest2(          SalesType.AsInteger(), SalesCode, WorkDate(), WorkDate(), CurrencyCode, Item."Base Unit of Measure", PriceLowerLimit, UnitPriceFactor, '', true);        if Item.HasFilter then            TmpItem.CopyFilters(Item)        else begin            Item.Get(Item."No.");            TmpItem.SetRange("No.", Item."No.");        end;        SuggestItemPriceOnWksh.SetTableView(TmpItem);        SuggestItemPriceOnWksh.UseRequestPage(false);        SuggestItemPriceOnWksh.RunModal();    end;    procedure SuggestItemStandardCost(var Item: Record Item; StandardCostWorksheetName: Code[10]; StandardCostAdjustmentFactor: Integer; StandardCostRoundingMethod: Code[10])    var        TmpItem: Record Item;        SuggestItemStandardCostReport: Report "Suggest Item Standard Cost";    begin        Clear(SuggestItemStandardCostReport);        SuggestItemStandardCostReport.Initialize(StandardCostWorksheetName, StandardCostAdjustmentFactor, 0, 0, StandardCostRoundingMethod, '', '');        if Item.HasFilter then            TmpItem.CopyFilters(Item)        else begin            Item.Get(Item."No.");            TmpItem.SetRange("No.", Item."No.");        end;        SuggestItemStandardCostReport.SetTableView(TmpItem);        SuggestItemStandardCostReport.UseRequestPage(false);        SuggestItemStandardCostReport.Run();    end;#if not CLEAN27#pragma warning disable AL0801    [Obsolete('Moved to codeunit LibraryManufacturing', '27.0')]    procedure UpdateUnitCost(var ProductionOrder: Record "Production Order"; CalcMethod: Option; UpdateReservations: Boolean)    var        LibraryManufacturing: Codeunit "Library - Manufacturing";    begin        LibraryManufacturing.UpdateUnitCost(ProductionOrder, CalcMethod, UpdateReservations);    end;#pragma warning restore AL0801#endif    local procedure UpdateBufferforRoundingCheck(var TempItemJournalBuffer: Record "Item Journal Buffer" temporary; EntryNo: Integer; Quantity: Decimal; CostAmount: Decimal)    begin        // Reduce the cost and quantity of outbound entry from the inbound buffer - only for completely invoiced outbound entries        if TempItemJournalBuffer.Get(EntryNo) then begin            TempItemJournalBuffer.Quantity += Quantity;            TempItemJournalBuffer."Inventory Value (Calculated)" += CostAmount;            TempItemJournalBuffer.Modify();        end;    end;    local procedure VerifyInboundEntriesRounding(var TempItemJournalBuffer: Record "Item Journal Buffer" temporary)    begin        // Verify that if the residual quantity is zero, the residual cost should also be zero        TempItemJournalBuffer.SetRange(Quantity, 0);        TempItemJournalBuffer.SetFilter("Inventory Value (Calculated)", '>%1', 0.01);        // Throws only the first rounding error        if TempItemJournalBuffer.FindFirst() then            Assert.Fail(              StrSubstNo(IncorrectRoundingTxt, TempItemJournalBuffer."Inventory Value (Calculated)", TempItemJournalBuffer."Line No."));    end;    procedure AssignItemChargePurch(PurchaseLineCharge: Record "Purchase Line"; AppliesTo: Variant)    var        ItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)";        DocumentType: Option;        ItemNo: Code[20];        DocumentNo: Code[20];        LineNo: Integer;    begin        GetAppliesToValues(AppliesTo, DocumentType, DocumentNo, LineNo, ItemNo);        ItemChargeAssignmentPurch.Init();        ItemChargeAssignmentPurch.Validate("Document Type", PurchaseLineCharge."Document Type");        ItemChargeAssignmentPurch.Validate("Document No.", PurchaseLineCharge."Document No.");        ItemChargeAssignmentPurch.Validate("Document Line No.", PurchaseLineCharge."Line No.");        ItemChargeAssignmentPurch.Validate("Item Charge No.", PurchaseLineCharge."No.");        ItemChargeAssignmentPurch.Validate("Applies-to Doc. Type", DocumentType);        ItemChargeAssignmentPurch.Validate("Applies-to Doc. No.", DocumentNo);        ItemChargeAssignmentPurch.Validate("Applies-to Doc. Line No.", LineNo);        ItemChargeAssignmentPurch.Validate("Unit Cost", PurchaseLineCharge."Unit Cost");        ItemChargeAssignmentPurch.Validate("Item No.", ItemNo);        ItemChargeAssignmentPurch.Validate("Qty. to Assign", PurchaseLineCharge.Quantity);        ItemChargeAssignmentPurch.Insert(true);    end;    procedure AssignItemChargeSales(SalesLineCharge: Record "Sales Line"; AppliesTo: Variant)    var        ItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)";        DocumentType: Option;        ItemNo: Code[20];        DocumentNo: Code[20];        LineNo: Integer;    begin        GetAppliesToValues(AppliesTo, DocumentType, DocumentNo, LineNo, ItemNo);        ItemChargeAssignmentSales.Init();        ItemChargeAssignmentSales.Validate("Document Type", SalesLineCharge."Document Type");        ItemChargeAssignmentSales.Validate("Document No.", SalesLineCharge."Document No.");        ItemChargeAssignmentSales.Validate("Document Line No.", SalesLineCharge."Line No.");        ItemChargeAssignmentSales.Validate("Item Charge No.", SalesLineCharge."No.");        ItemChargeAssignmentSales.Validate("Applies-to Doc. Type", DocumentType);        ItemChargeAssignmentSales.Validate("Applies-to Doc. No.", DocumentNo);        ItemChargeAssignmentSales.Validate("Applies-to Doc. Line No.", LineNo);        ItemChargeAssignmentSales.Validate("Unit Cost", SalesLineCharge."Unit Cost");        ItemChargeAssignmentSales.Validate("Item No.", ItemNo);        ItemChargeAssignmentSales.Validate("Qty. to Assign", SalesLineCharge.Quantity);        ItemChargeAssignmentSales.Insert(true);    end;    local procedure GetAppliesToValues(AppliesTo: Variant; var DocumentType: Option; var DocumentNo: Code[20]; var LineNo: Integer; var ItemNo: Code[20])    var        PurchaseLine: Record "Purchase Line";        PurchRcptLine: Record "Purch. Rcpt. Line";        SalesLine: Record "Sales Line";        SalesShptLine: Record "Sales Shipment Line";        ItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)";        ItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)";        RecRef: RecordRef;    begin        if not AppliesTo.IsRecord then            Error(ShouldBeOfRecordTypeErr);        RecRef.GetTable(AppliesTo);        case RecRef.Number of            DATABASE::"Purchase Line":                begin                    PurchaseLine := AppliesTo;                    DocumentType := PurchaseLine."Document Type".AsInteger();                    DocumentNo := PurchaseLine."Document No.";                    LineNo := PurchaseLine."Line No.";                    ItemNo := PurchaseLine."No.";                end;            DATABASE::"Purch. Rcpt. Line":                begin                    PurchRcptLine := AppliesTo;                    DocumentType := ItemChargeAssignmentPurch."Applies-to Doc. Type"::Receipt.AsInteger();                    DocumentNo := PurchRcptLine."Document No.";                    LineNo := PurchRcptLine."Line No.";                    ItemNo := PurchRcptLine."No.";                end;            DATABASE::"Sales Line":                begin                    SalesLine := AppliesTo;                    DocumentType := SalesLine."Document Type".AsInteger();                    DocumentNo := SalesLine."Document No.";                    LineNo := SalesLine."Line No.";                    ItemNo := SalesLine."No.";                end;            DATABASE::"Sales Shipment Line":                begin                    SalesShptLine := AppliesTo;                    DocumentType := ItemChargeAssignmentSales."Applies-to Doc. Type"::Shipment.AsInteger();                    DocumentNo := SalesShptLine."Document No.";                    LineNo := SalesShptLine."Line No.";                    ItemNo := SalesShptLine."No.";                end;            else                Error(WrongRecordTypeErr);        end;    end;}