Codeunit 22 Item Jnl.-Post Line
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;}