Codeunit 99000830 Create Reserv. Entry
src/Layers/W1/BaseApp/Inventory/Tracking/CreateReservEntry.Codeunit.al1,342 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.Tracking;using Microsoft.Foundation.UOM;using Microsoft.Inventory.Counting.Document;using Microsoft.Inventory.Document;using Microsoft.Inventory.Item;using Microsoft.Inventory.Journal;using Microsoft.Inventory.Ledger;using Microsoft.Inventory.Location;using Microsoft.Inventory.Planning;using Microsoft.Inventory.Requisition;using Microsoft.Inventory.Transfer;using Microsoft.Projects.Project.Job;using Microsoft.Projects.Project.Journal;using Microsoft.Projects.Project.Planning;using Microsoft.Purchases.Document;using Microsoft.Sales.Document;using Microsoft.Warehouse.Document;using Microsoft.Warehouse.Tracking;using Microsoft.Warehouse.Worksheet;codeunit 99000830 "Create Reserv. Entry"{ Permissions = TableData "Reservation Entry" = rim; trigger OnRun() begin end; var InsertReservEntry: Record "Reservation Entry"; InsertReservEntry2: Record "Reservation Entry"; LastReservEntry: Record "Reservation Entry"; TempTrkgSpec1: Record "Tracking Specification" temporary; TempTrkgSpec2: Record "Tracking Specification" temporary; UOMMgt: Codeunit "Unit of Measure Management"; OverruleItemTracking: Boolean; Inbound: Boolean; UseQtyToInvoice: Boolean; QtyToHandleAndInvoiceIsSet: Boolean; LastProcessedSourceID: Text; CalledFromInvtPutawayPick: Boolean;#pragma warning disable AA0074 Text000: Label 'You cannot reserve this entry because it is not a true demand or supply.'; Text001: Label 'Cannot match item tracking.';#pragma warning restore AA0074 procedure CreateEntry(ItemNo: Code[20]; VariantCode: Code[10]; LocationCode: Code[10]; Description: Text[100]; ExpectedReceiptDate: Date; ShipmentDate: Date; TransferredFromEntryNo: Integer; Status: Enum "Reservation Status") var ReservEntry: Record "Reservation Entry"; ReservEntry2: Record "Reservation Entry"; ReservMgt: Codeunit "Reservation Management"; TrackingSpecificationExists: Boolean; FirstSplit: Boolean; IsHandled: Boolean; begin OnBeforeCreateEntry(ItemNo, VariantCode, LocationCode, Description, ExpectedReceiptDate, ShipmentDate, TransferredFromEntryNo, Status); TempTrkgSpec1.Reset(); TempTrkgSpec2.Reset(); TempTrkgSpec1.DeleteAll(); TempTrkgSpec2.DeleteAll(); // Status Surplus gets special treatment. if (Status = Status::Reservation) or (Status = Status::Tracking) then if InsertReservEntry."Quantity (Base)" = 0 then exit; InsertReservEntry.TestField("Source Type"); ReservEntry := InsertReservEntry; ReservEntry."Reservation Status" := Status; ReservEntry."Item No." := ItemNo; ReservEntry."Variant Code" := VariantCode; ReservEntry."Location Code" := LocationCode; ReservEntry.Description := Description; ReservEntry."Creation Date" := WorkDate(); ReservEntry."Created By" := CopyStr(UserId(), 1, 50); ReservEntry."Expected Receipt Date" := ExpectedReceiptDate; ReservEntry."Shipment Date" := ShipmentDate; ReservEntry."Transferred from Entry No." := TransferredFromEntryNo; ReservEntry.Positive := (ReservEntry."Quantity (Base)" > 0); if (ReservEntry."Quantity (Base)" <> 0) and ((ReservEntry.Quantity = 0) or (ReservEntry."Qty. per Unit of Measure" <> InsertReservEntry2."Qty. per Unit of Measure")) then ReservEntry.Quantity := Round(ReservEntry."Quantity (Base)" / ReservEntry."Qty. per Unit of Measure", UOMMgt.QtyRndPrecision()); if not QtyToHandleAndInvoiceIsSet then begin ReservEntry."Qty. to Handle (Base)" := ReservEntry."Quantity (Base)"; ReservEntry."Qty. to Invoice (Base)" := ReservEntry."Quantity (Base)"; end; ReservEntry."Untracked Surplus" := InsertReservEntry."Untracked Surplus" and not ReservEntry.Positive; OnCreateEntryOnBeforeSurplusCondition(ReservEntry, QtyToHandleAndInvoiceIsSet, InsertReservEntry); if (Status = Status::Reservation) or (Status = Status::Tracking) then begin InsertReservEntry2.TestField("Source Type"); ReservEntry2 := ReservEntry; ReservEntry2."Quantity (Base)" := -ReservEntry."Quantity (Base)"; ReservEntry2.Quantity := Round(ReservEntry2."Quantity (Base)" / InsertReservEntry2."Qty. per Unit of Measure", UOMMgt.QtyRndPrecision()); ReservEntry2."Qty. to Handle (Base)" := -ReservEntry."Qty. to Handle (Base)"; ReservEntry2."Qty. to Invoice (Base)" := -ReservEntry."Qty. to Invoice (Base)"; ReservEntry2.Positive := (ReservEntry2."Quantity (Base)" > 0); ReservEntry2."Source Type" := InsertReservEntry2."Source Type"; ReservEntry2."Source Subtype" := InsertReservEntry2."Source Subtype"; ReservEntry2."Source ID" := InsertReservEntry2."Source ID"; ReservEntry2."Source Batch Name" := InsertReservEntry2."Source Batch Name"; ReservEntry2."Source Prod. Order Line" := InsertReservEntry2."Source Prod. Order Line"; ReservEntry2."Source Ref. No." := InsertReservEntry2."Source Ref. No."; ReservEntry2.CopyTrackingFromreservEntry(InsertReservEntry2); ReservEntry2."Expiration Date" := ReservEntry."Expiration Date"; ReservEntry2."Qty. per Unit of Measure" := InsertReservEntry2."Qty. per Unit of Measure"; ReservEntry2."Untracked Surplus" := InsertReservEntry2."Untracked Surplus" and not ReservEntry2.Positive; OnAfterCopyFromInsertReservEntry(InsertReservEntry2, ReservEntry2, ReservEntry, Status, QtyToHandleAndInvoiceIsSet); if not QtyToHandleAndInvoiceIsSet then begin ReservEntry2."Qty. to Handle (Base)" := ReservEntry2."Quantity (Base)"; ReservEntry2."Qty. to Invoice (Base)" := ReservEntry2."Quantity (Base)"; end; ReservEntry2.ClearApplFromToItemEntry(); if Status = Status::Reservation then if TransferredFromEntryNo = 0 then begin ReservMgt.MakeRoomForReservation(ReservEntry2); TrackingSpecificationExists := ReservMgt.CollectTrackingSpecification(TempTrkgSpec2); OnCreateEntryOnAfterCollectTrackingSpecificationTempTrkgSpec2(TempTrkgSpec2, ReservEntry2, TrackingSpecificationExists); end; CheckValidity(ReservEntry2); AdjustDateIfItemLedgerEntry(ReservEntry2); end; ReservEntry.ClearApplFromToItemEntry(); CheckValidity(ReservEntry); AdjustDateIfItemLedgerEntry(ReservEntry); if Status = Status::Reservation then if TransferredFromEntryNo = 0 then begin ReservMgt.MakeRoomForReservation(ReservEntry); TrackingSpecificationExists := TrackingSpecificationExists or ReservMgt.CollectTrackingSpecification(TempTrkgSpec1); end; if TrackingSpecificationExists then SetupSplitReservEntry(ReservEntry, ReservEntry2); OnCreateEntryOnBeforeOnBeforeSplitReservEntry(ReservEntry, ReservEntry2); FirstSplit := true; IsHandled := false; OnCreateEntryOnBeforeSplitReservEntryLoop(ReservEntry, ReservEntry2, TrackingSpecificationExists, FirstSplit, IsHandled); if not IsHandled then while SplitReservEntry(ReservEntry, ReservEntry2, TrackingSpecificationExists, FirstSplit) do begin ReservEntry."Entry No." := 0; ReservEntry.UpdateItemTracking(); OnBeforeReservEntryInsert(ReservEntry); ReservEntry.Insert(); if TransferredFromEntryNo = 0 then CheckReservationEntryForRoundingQty(ReservEntry); OnAfterReservEntryInsert(ReservEntry); if (Status = Status::Reservation) or (Status = Status::Tracking) then begin ReservEntry2."Entry No." := ReservEntry."Entry No."; OnBeforeReservEntryUpdateItemTracking(ReservEntry, ReservEntry2); ReservEntry2.UpdateItemTracking(); OnBeforeReservEntryInsertNonSurplus(ReservEntry2); ReservEntry2.Insert(); OnAfterReservEntryInsertNonSurplus(ReservEntry2, ReservEntry); end; end; LastReservEntry := ReservEntry; Clear(InsertReservEntry); Clear(InsertReservEntry2); Clear(QtyToHandleAndInvoiceIsSet); OnAfterCreateEntry(ItemNo, VariantCode, LocationCode); end; procedure CheckReservationEntryForRoundingQty(ReservEntry: Record "Reservation Entry") var Item: Record Item; ReservationEntry: Record "Reservation Entry"; SalesLine: Record "Sales Line"; SaleLineQty: Decimal; RoundQty: Decimal; begin Item.Get(ReservEntry."Item No."); if Item.Reserve <> Item."Reserve"::"Always" then exit; if SalesLine.Get(ReservEntry."Source Subtype", ReservEntry."Source ID", ReservEntry."Source Ref. No.") then SaleLineQty := SalesLine.Quantity else exit; ReservationEntry.SetLoadFields("Source Type", "Source Subtype", "Source ID", "Source Ref. No.", Quantity); ReservationEntry.SetRange("Source Type", ReservEntry."Source Type"); ReservationEntry.SetRange("Source Subtype", ReservEntry."Source Subtype"); ReservationEntry.SetRange("Source ID", ReservEntry."Source ID"); ReservationEntry.SetRange("Source Ref. No.", ReservEntry."Source Ref. No."); ReservationEntry.CalcSums(Quantity); if Abs(ReservationEntry.Quantity) > SaleLineQty then begin RoundQty := SaleLineQty - Abs(ReservationEntry.Quantity); ReservEntry.Validate(Quantity, (ReservEntry.Quantity - RoundQty)); ReservEntry.Modify(); end; end; procedure CreateReservEntry(ItemNo: Code[20]; VariantCode: Code[10]; LocationCode: Code[10]; Description: Text[100]; ExpectedReceiptDate: Date; ShipmentDate: Date) var ReservationStatus: Enum "Reservation Status"; begin OnBeforeCreateReservEntry(ItemNo, VariantCode, LocationCode, Description, ExpectedReceiptDate, ShipmentDate); CreateEntry(ItemNo, VariantCode, LocationCode, Description, ExpectedReceiptDate, ShipmentDate, 0, ReservationStatus::Reservation); end; procedure CreateReservEntry(ItemNo: Code[20]; VariantCode: Code[10]; LocationCode: Code[10]; Description: Text[100]; ExpectedReceiptDate: Date; ShipmentDate: Date; TransferedFromEntryNo: Integer) var ReservationStatus: Enum "Reservation Status"; begin CreateEntry(ItemNo, VariantCode, LocationCode, Description, ExpectedReceiptDate, ShipmentDate, TransferedFromEntryNo, ReservationStatus::Reservation); end; procedure CreateReservEntryFor(ForType: Option; ForSubtype: Integer; ForID: Code[20]; ForBatchName: Code[10]; ForProdOrderLine: Integer; ForRefNo: Integer; ForQtyPerUOM: Decimal; Quantity: Decimal; QuantityBase: Decimal; ForReservEntry: Record "Reservation Entry") var Sign: Integer; begin InsertReservEntry.SetSource(ForType, ForSubtype, ForID, ForRefNo, ForBatchName, ForProdOrderLine); Sign := SignFactor(InsertReservEntry); InsertReservEntry.Quantity := Sign * Quantity; InsertReservEntry."Quantity (Base)" := Sign * QuantityBase; InsertReservEntry."Qty. per Unit of Measure" := ForQtyPerUOM; InsertReservEntry.CopyTrackingFromreservEntry(ForReservEntry); InsertReservEntry.TestField("Qty. per Unit of Measure"); OnAfterCreateReservEntryFor(InsertReservEntry, Sign, ForType, ForSubtype, ForID, ForBatchName, ForProdOrderLine, ForRefNo, ForQtyPerUOM, Quantity, QuantityBase, ForReservEntry); end; procedure CreateReservEntryFrom(FromTrackingSpecification: Record "Tracking Specification") begin InsertReservEntry2.Init(); InsertReservEntry2.SetSource( FromTrackingSpecification."Source Type", FromTrackingSpecification."Source Subtype", FromTrackingSpecification."Source ID", FromTrackingSpecification."Source Ref. No.", FromTrackingSpecification."Source Batch Name", FromTrackingSpecification."Source Prod. Order Line"); InsertReservEntry2."Qty. per Unit of Measure" := FromTrackingSpecification."Qty. per Unit of Measure"; InsertReservEntry2.CopyTrackingFromSpec(FromTrackingSpecification); InsertReservEntry2.TestField("Qty. per Unit of Measure"); OnAfterCreateReservEntryFrom(InsertReservEntry2); end; procedure CreateReservEntryExtraFields(var OldTrackingSpecification: Record "Tracking Specification"; var NewTrackingSpecification: Record "Tracking Specification") begin OnCreateReservEntryExtraFields(InsertReservEntry, OldTrackingSpecification, NewTrackingSpecification); end; procedure SetBinding(Binding: Enum "Reservation Binding") begin InsertReservEntry.Binding := Binding; InsertReservEntry2.Binding := Binding; end; procedure SetPlanningFlexibility(Flexibility: Enum "Reservation Planning Flexibility") begin InsertReservEntry."Planning Flexibility" := Flexibility; InsertReservEntry2."Planning Flexibility" := Flexibility; end; procedure SetDates(WarrantyDate: Date; ExpirationDate: Date) begin InsertReservEntry."Warranty Date" := WarrantyDate; InsertReservEntry."Expiration Date" := ExpirationDate; OnAfterSetDates(InsertReservEntry); end; procedure SetQtyToHandleAndInvoice(QtyToHandleBase: Decimal; QtyToInvoiceBase: Decimal) begin InsertReservEntry."Qty. to Handle (Base)" := QtyToHandleBase; InsertReservEntry."Qty. to Invoice (Base)" := QtyToInvoiceBase; QtyToHandleAndInvoiceIsSet := true; OnAfterSetQtyToHandleAndInvoice(InsertReservEntry); end; procedure SetNewTrackingFromItemJnlLine(ItemJnlLine: Record "Item Journal Line") begin InsertReservEntry."New Serial No." := ItemJnlLine."Serial No."; InsertReservEntry."New Lot No." := ItemJnlLine."Lot No."; OnAfterSetNewTrackingFromItemJnlLine(InsertReservEntry, ItemJnlLine); end; procedure SetNewTrackingFromNewTrackingSpecification(TrackingSpecification: Record "Tracking Specification") begin InsertReservEntry."New Serial No." := TrackingSpecification."New Serial No."; InsertReservEntry."New Lot No." := TrackingSpecification."New Lot No."; OnAfterSetNewTrackingFromNewTrackingSpecification(InsertReservEntry, TrackingSpecification); end; procedure SetNewTrackingFromNewWhseItemTrackingLine(WhseItemTrackingLine: Record "Whse. Item Tracking Line") begin InsertReservEntry."New Serial No." := WhseItemTrackingLine."New Serial No."; InsertReservEntry."New Lot No." := WhseItemTrackingLine."New Lot No."; OnAfterSetNewTrackingFromNewWhseItemTrackingLine(InsertReservEntry, WhseItemTrackingLine); end; procedure SetNewExpirationDate(NewExpirationDate: Date) begin InsertReservEntry."New Expiration Date" := NewExpirationDate; end; procedure SetDisallowCancellation(NewDisallowCancellation: Boolean) begin InsertReservEntry."Disallow Cancellation" := NewDisallowCancellation; end; procedure CreateRemainingReservEntry(var OldReservEntry: Record "Reservation Entry"; RemainingQuantity: Decimal; RemainingQuantityBase: Decimal) var OldReservEntry2: Record "Reservation Entry"; FromTracingSpecification: Record "Tracking Specification"; begin if CalledFromInvtPutawayPick then exit; OnBeforeCreateRemainingReservEntryProcedure(OldReservEntry); CreateReservEntryFor( OldReservEntry."Source Type", OldReservEntry."Source Subtype", OldReservEntry."Source ID", OldReservEntry."Source Batch Name", OldReservEntry."Source Prod. Order Line", OldReservEntry."Source Ref. No.", OldReservEntry."Qty. per Unit of Measure", RemainingQuantity, RemainingQuantityBase, OldReservEntry); InsertReservEntry."Warranty Date" := OldReservEntry."Warranty Date"; InsertReservEntry."Expiration Date" := OldReservEntry."Expiration Date"; OnBeforeCreateRemainingReservEntry(InsertReservEntry, OldReservEntry); if (OldReservEntry."Reservation Status" = OldReservEntry."Reservation Status"::Reservation) or (OldReservEntry."Reservation Status" = OldReservEntry."Reservation Status"::Tracking) then if OldReservEntry2.Get(OldReservEntry."Entry No.", not OldReservEntry.Positive) then begin // Get the related entry FromTracingSpecification.SetSourceFromReservEntry((OldReservEntry2)); FromTracingSpecification."Qty. per Unit of Measure" := OldReservEntry2."Qty. per Unit of Measure"; FromTracingSpecification.CopyTrackingFromReservEntry(OldReservEntry2); OnCreateRemainingReservEntryOnBeforeCreateReservEntryFrom(OldReservEntry2); CreateReservEntryFrom(FromTracingSpecification); InsertReservEntry2."Warranty Date" := OldReservEntry2."Warranty Date"; InsertReservEntry2."Expiration Date" := OldReservEntry2."Expiration Date"; OnBeforeCreateRemainingNonSurplusReservEntry(InsertReservEntry2, OldReservEntry2); end; CreateEntry( OldReservEntry."Item No.", OldReservEntry."Variant Code", OldReservEntry."Location Code", OldReservEntry.Description, OldReservEntry."Expected Receipt Date", OldReservEntry."Shipment Date", OldReservEntry."Entry No.", OldReservEntry."Reservation Status"); OnAfterCreateRemainingReservEntry(OldReservEntry, LastReservEntry); end; internal procedure SetCalledFromInvtPutawayPick(CalledFromInvtPutawayPickVal: Boolean) begin CalledFromInvtPutawayPick := CalledFromInvtPutawayPickVal; end; procedure TransferReservEntry(NewType: Option; NewSubtype: Integer; NewID: Code[20]; NewBatchName: Code[10]; NewProdOrderLine: Integer; NewRefNo: Integer; QtyPerUOM: Decimal; OldReservEntry: Record "Reservation Entry"; TransferQty: Decimal): Decimal var NewReservEntry: Record "Reservation Entry"; ReservEntry: Record "Reservation Entry"; CarriedReservationEntry: Record "Reservation Entry"; Location: Record Location; CarriedItemTrackingSetup: Record "Item Tracking Setup"; ItemTrkgMgt: Codeunit "Item Tracking Management"; CurrSignFactor: Integer; xTransferQty: Decimal; QtyToHandleThisLine: Decimal; QtyToInvoiceThisLine: Decimal; QtyInvoiced: Decimal; UseQtyToHandle: Boolean; IsHandled: Boolean; DoCreateNewButUnchangedVersion: Boolean; ShouldCreateWhseItemTrkgLines: Boolean; NewTrackingTransferred: Boolean; begin if TransferQty = 0 then exit; UseQtyToHandle := OldReservEntry.TrackingExists() and not OverruleItemTracking; CurrSignFactor := SignFactor(OldReservEntry); TransferQty := TransferQty * CurrSignFactor; xTransferQty := TransferQty; if UseQtyToHandle then begin // Used when handling Item Tracking QtyToHandleThisLine := OldReservEntry."Qty. to Handle (Base)"; QtyToInvoiceThisLine := OldReservEntry."Qty. to Invoice (Base)"; if Abs(TransferQty) > Abs(QtyToHandleThisLine) then TransferQty := QtyToHandleThisLine; if UseQtyToInvoice then // Used when posting sales and purchase if Abs(TransferQty) > Abs(QtyToInvoiceThisLine) then TransferQty := QtyToInvoiceThisLine; end else QtyToHandleThisLine := OldReservEntry."Quantity (Base)"; if QtyToHandleThisLine = 0 then exit(xTransferQty * CurrSignFactor); OnTransferReservEntryOnBeforeTransferFields(OldReservEntry, UseQtyToHandle, UseQtyToInvoice, CurrSignFactor); NewReservEntry.TransferFields(OldReservEntry, false); OnTransferReservEntryOnAfterTransferFields(NewReservEntry, OldReservEntry, UseQtyToHandle, UseQtyToInvoice, CurrSignFactor); NewReservEntry."Entry No." := OldReservEntry."Entry No."; NewReservEntry.Positive := OldReservEntry.Positive; NewReservEntry.SetSource(NewType, NewSubtype, NewID, NewRefNo, NewBatchName, NewProdOrderLine); NewReservEntry."Qty. per Unit of Measure" := QtyPerUOM; // Item Tracking on consumption, output and drop shipment: if (NewType = Database::"Item Journal Line") and (NewSubtype in [3, 5, 6]) or OverruleItemTracking then if InsertReservEntry.NewTrackingExists() then begin NewReservEntry.CopyTrackingFromReservEntryNewTracking(InsertReservEntry); NewTrackingTransferred := true; if NewReservEntry."Qty. to Handle (Base)" = 0 then NewReservEntry."Qty. to Handle (Base)" := NewReservEntry."Quantity (Base)"; // If an order-to-order supply is being posted, item tracking must be carried to the related demand: if (TransferQty >= 0) and (NewReservEntry.Binding = NewReservEntry.Binding::"Order-to-Order") then begin CarriedReservationEntry := InsertReservEntry; CarriedItemTrackingSetup.CopyTrackingFromReservEntry(NewReservEntry); if not UseQtyToHandle then // the IT is set only in Consumption/Output Journal and we need to update all fields properly QtyToInvoiceThisLine := NewReservEntry."Quantity (Base)"; end; OnTransferReservEntryOnNewItemTracking(NewReservEntry, InsertReservEntry, TransferQty); end; if InsertReservEntry."Item Ledger Entry No." <> 0 then begin NewReservEntry."Item Ledger Entry No." := InsertReservEntry."Item Ledger Entry No."; InsertReservEntry."Item Ledger Entry No." := 0; end; if NewReservEntry."Source Type" = Database::"Item Ledger Entry" then if NewReservEntry."Quantity (Base)" > 0 then NewReservEntry."Expected Receipt Date" := 0D else NewReservEntry."Shipment Date" := DMY2Date(31, 12, 9999); NewReservEntry.UpdateItemTracking(); DoCreateNewButUnchangedVersion := (TransferQty >= 0) <> OldReservEntry.Positive; OnTransferReservEntryOnAfterCalcNewButUnchangedVersion(NewReservEntry, OldReservEntry, TransferQty, DoCreateNewButUnchangedVersion); if DoCreateNewButUnchangedVersion then begin // If sign has swapped due to negative posting // Create a new but unchanged version of the original reserventry: IsHandled := false; OnTransferReservEntryOnBeforeCreateNewReservEntry(NewReservEntry, OldReservEntry, IsHandled, TransferQty); if not IsHandled then begin SetQtyToHandleAndInvoice(QtyToHandleThisLine, QtyToInvoiceThisLine); if NewTrackingTransferred then InsertReservEntry.ClearNewTracking(); // The remaining entry stays on the original source CreateRemainingReservEntry(OldReservEntry, OldReservEntry.Quantity * CurrSignFactor, OldReservEntry."Quantity (Base)" * CurrSignFactor); NewReservEntry.Validate("Quantity (Base)", TransferQty); // Correct primary key - swap "Positive": NewReservEntry.Positive := not NewReservEntry.Positive; if not ReservEntry.Get(NewReservEntry."Entry No.", NewReservEntry.Positive) then begin // Means that only one record exists = surplus or prospect NewReservEntry.Insert(); OnTransferReservEntryOnAfterNewReservEntryInsert(NewReservEntry); // Delete the original record: NewReservEntry.Positive := not NewReservEntry.Positive; NewReservEntry.Delete(); end else begin // A set of records exist = reservation or tracking OnTransferReservEntryOnBeforeNewReservEntryModify(NewReservEntry, false); NewReservEntry.Modify(); // Get the original record and modify quantity: NewReservEntry.Get(NewReservEntry."Entry No.", not NewReservEntry.Positive); // Get partner-record NewReservEntry.Validate("Quantity (Base)", -TransferQty); OnTransferReservEntryOnBeforeNewReservEntryModify(NewReservEntry, true); NewReservEntry.Modify(); end; end; end else if Abs(TransferQty) < Abs(OldReservEntry."Quantity (Base)") then begin OnBeforeUseOldReservEntry(OldReservEntry, InsertReservEntry, CurrSignFactor); if OldReservEntry.Binding = OldReservEntry.Binding::"Order-to-Order" then SetBinding(OldReservEntry.Binding::"Order-to-Order"); if OldReservEntry."Disallow Cancellation" then SetDisallowCancellation(OldReservEntry."Disallow Cancellation"); if Abs(QtyToInvoiceThisLine) > Abs(TransferQty) then QtyInvoiced := TransferQty else QtyInvoiced := QtyToInvoiceThisLine; SetQtyToHandleAndInvoice(QtyToHandleThisLine - TransferQty, QtyToInvoiceThisLine - QtyInvoiced); OnTransferReservEntryOnBeforeCreateRemainingReservEntry(OldReservEntry, NewReservEntry, TransferQty); if NewTrackingTransferred then InsertReservEntry.ClearNewTracking(); // The remaining entry stays on the original source CreateRemainingReservEntry(OldReservEntry, 0, (OldReservEntry."Quantity (Base)" - TransferQty) * CurrSignFactor); NewReservEntry.Validate("Quantity (Base)", TransferQty); OnTransferReservEntryOnBeforeNewReservEntryModify(NewReservEntry, false); NewReservEntry.Modify(); if NewReservEntry.Get(NewReservEntry."Entry No.", not NewReservEntry.Positive) then begin // Get partner-record NewReservEntry.Validate("Quantity (Base)", -TransferQty); if NewReservEntry."Quantity (Base)" < 0 then // Adjust the expected receipt date and shipment date NewReservEntry."Expected Receipt Date" := 0D else NewReservEntry."Shipment Date" := DMY2Date(31, 12, 9999); OnTransferReservEntryOnBeforeNewReservEntryModify(NewReservEntry, true); NewReservEntry.Modify(); end; end else begin SetQtyToHandleAndInvoiceForReservationWithoutItemTracking(NewReservEntry, NewReservEntry."Quantity (Base)", NewReservEntry."Quantity (Base)", false); OnTransferReservEntryOnBeforeNewReservEntryModify(NewReservEntry, false); NewReservEntry.Modify(); TransferQty := NewReservEntry."Quantity (Base)"; if NewReservEntry."Source Type" = Database::"Item Ledger Entry" then begin if NewReservEntry.Get(NewReservEntry."Entry No.", not NewReservEntry.Positive) then begin // Get partner-record SetQtyToHandleAndInvoiceForReservationWithoutItemTracking(NewReservEntry, NewReservEntry."Quantity (Base)", NewReservEntry."Quantity (Base)", false); if NewReservEntry."Quantity (Base)" < 0 then NewReservEntry."Expected Receipt Date" := 0D else NewReservEntry."Shipment Date" := DMY2Date(31, 12, 9999); OnTransferReservEntryOnBeforeNewReservEntryModify(NewReservEntry, true); NewReservEntry.Modify(); end; // If necessary create Whse. Item Tracking Lines if (NewReservEntry."Source Type" = Database::"Sales Line") and (OldReservEntry."Source Type" = Database::"Item Journal Line") and (OldReservEntry."Reservation Status" = OldReservEntry."Reservation Status"::Reservation) then begin ShouldCreateWhseItemTrkgLines := ItemTrkgMgt.GetWhseItemTrkgSetup(OldReservEntry."Item No.") and Location.RequireShipment(OldReservEntry."Location Code"); OnTransferReservEntryOnAfterCalcShouldCreateWhseItemTrkgLines(OldReservEntry, ShouldCreateWhseItemTrkgLines); if ShouldCreateWhseItemTrkgLines then CreateWhseItemTrkgLines(NewReservEntry); end; end else if CarriedItemTrackingSetup.TrackingExists() then if NewReservEntry.Get(NewReservEntry."Entry No.", not NewReservEntry.Positive) then; // Get partner-record SetQtyToHandleAndInvoiceForReservationWithoutItemTracking(NewReservEntry, NewReservEntry."Quantity (Base)", NewReservEntry."Quantity (Base)", true); end; OnTransferReservEntryOnBeforeCheckCarriedItemTrackingSetupTrackingExists(NewReservEntry, OldReservEntry); if CarriedItemTrackingSetup.TrackingExists() then begin if NewReservEntry."Qty. to Handle (Base)" = 0 then NewReservEntry.Validate("Quantity (Base)"); NewReservEntry.CopyTrackingFromItemTrackingSetup(CarriedItemTrackingSetup); OnTransferReservEntryOnBeforeUpdateItemTracking(NewReservEntry, CarriedReservationEntry); NewReservEntry.UpdateItemTracking(); if NewReservEntry.Modify() then; end; SynchronizeTransferOutboundToInboundItemTracking(NewReservEntry."Entry No."); ClearNewItemTracking(NewType, NewSubtype, (xTransferQty - TransferQty)); OnAfterTransferReservEntry(NewReservEntry, OldReservEntry); xTransferQty -= TransferQty; exit(xTransferQty * CurrSignFactor); end; procedure SignFactor(var ReservEntry: Record "Reservation Entry"): Integer var Sign: Integer; begin OnBeforeSignFactor(ReservEntry, Inbound, Sign); // Demand is regarded as negative, supply is regarded as positive. case ReservEntry."Source Type" of Database::"Sales Line": if ReservEntry."Source Subtype" in [3, 5] then // Credit memo, Return Order = supply Sign := 1 else Sign := -1; Database::"Requisition Line": if ReservEntry."Source Subtype" = 1 then Sign := -1 else Sign := 1; Database::"Purchase Line": if ReservEntry."Source Subtype" in [3, 5] then // Credit memo, Return Order = demand Sign := -1 else Sign := 1; Database::"Item Journal Line": if (ReservEntry."Source Subtype" = 4) and Inbound then Sign := 1 else if ReservEntry."Source Subtype" in [1, 3, 4, 5] then // Sale, Negative Adjmt., Transfer, Consumption Sign := -1 else Sign := 1; Database::"Job Journal Line": Sign := -1; Database::"Item Ledger Entry": Sign := 1; Database::"Planning Component": Sign := -1; Database::"Transfer Line": if ReservEntry."Source Subtype" = 0 then // Outbound Sign := -1 else Sign := 1; Database::"Job Planning Line", Database::Job: Sign := -1; Database::"Phys. Invt. Order Line": if ReservEntry.Positive then Sign := 1 else Sign := -1; Database::"Invt. Document Line": if ReservEntry."Source Subtype" = 0 then // Receipt Sign := 1 else Sign := -1; // Use table IDs for performance reasons 5406: // Database::"Prod. Order Line": Sign := 1; 5407: // Database::"Prod. Order Component": Sign := -1; 900: // Database::"Assembly Header": Sign := 1; 901: // Database::"Assembly Line": Sign := -1; 5902: // Database::"Service Line": if ReservEntry."Source Subtype" in [3] then // Credit memo Sign := 1 else Sign := -1; end; OnAfterSignFactor(ReservEntry, Sign); exit(Sign); end; local procedure CheckValidity(var ReservEntry: Record "Reservation Entry") var IsError: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckValidity(ReservEntry, IsHandled); if IsHandled then exit; if ReservEntry."Reservation Status" <> ReservEntry."Reservation Status"::Reservation then exit; IsError := CheckSourceTypeSubtype(ReservEntry); if IsError then Error(Text000); end; local procedure CheckSourceTypeSubtype(var ReservEntry: Record "Reservation Entry") IsError: Boolean begin // This event used internally for base app source tables OnCheckSourceTypeSubtype(ReservEntry, IsError); // This event used for compatibility with previous versions OnAfterCheckValidity(ReservEntry, IsError); // This event used for external extensions OnAfterCheckSourceTypeSubtype(ReservEntry, IsError); end; procedure GetLastEntry(var ReservEntry: Record "Reservation Entry") begin ReservEntry := LastReservEntry; end; procedure GetLastInsertReservEntry(var ReservEntry: Record "Reservation Entry") begin ReservEntry := InsertReservEntry; end; local procedure AdjustDateIfItemLedgerEntry(var ReservEntry: Record "Reservation Entry") begin if ReservEntry."Source Type" = Database::"Item Ledger Entry" then if ReservEntry."Quantity (Base)" > 0 then ReservEntry."Expected Receipt Date" := 0D else ReservEntry."Shipment Date" := DMY2Date(31, 12, 9999); end; local procedure SetupSplitReservEntry(var ReservEntry: Record "Reservation Entry"; var ReservEntry2: Record "Reservation Entry") var NonReleasedQty: Decimal; begin // Preparing the looping through Item Tracking. // Ensure that the full quantity is represented in the list of Tracking Specifications: NonReleasedQty := ReservEntry."Quantity (Base)"; if TempTrkgSpec1.FindSet() then repeat NonReleasedQty -= TempTrkgSpec1."Quantity (Base)"; until TempTrkgSpec1.Next() = 0; if NonReleasedQty <> 0 then InsertTempTrackingSpecification(TempTrkgSpec1, ReservEntry, NonReleasedQty); if not ReservEntry.IsReservationOrTracking() then exit; NonReleasedQty := ReservEntry2."Quantity (Base)"; if TempTrkgSpec2.FindSet() then repeat NonReleasedQty -= TempTrkgSpec2."Quantity (Base)"; until TempTrkgSpec2.Next() = 0; if NonReleasedQty <> 0 then InsertTempTrackingSpecification(TempTrkgSpec2, ReservEntry2, NonReleasedQty); BalanceLists(); end; local procedure InsertTempTrackingSpecification(var TempTrkgSpec: Record "Tracking Specification" temporary; ReservEntry: Record "Reservation Entry"; NonReleasedQty: Decimal) var IsHandled: Boolean; begin TempTrkgSpec.Init(); TempTrkgSpec.TransferFields(ReservEntry); TempTrkgSpec.Validate("Quantity (Base)", NonReleasedQty); IsHandled := false; OnBeforeClearTracking(ReservEntry, IsHandled); if not IsHandled then if (TempTrkgSpec."Source Type" <> Database::"Item Ledger Entry") and (ReservEntry."Reservation Status" <> ReservEntry."Reservation Status"::Reservation) then TempTrkgSpec.ClearTracking(); TempTrkgSpec.Insert(); end; local procedure BalanceLists() var TempTrkgSpec3: Record "Tracking Specification" temporary; TempTrkgSpec4: Record "Tracking Specification" temporary; LastEntryNo: Integer; NextState: Option SetFilter1,SetFilter2,LoosenFilter1,LoosenFilter2,Split,Error,Finish; IsHandled: Boolean; begin LastEntryNo := 0; TempTrkgSpec1.Reset(); TempTrkgSpec2.Reset(); TempTrkgSpec1.SetTrackingKey(); TempTrkgSpec2.SetTrackingKey(); if not TempTrkgSpec1.FindLast() then exit; repeat case NextState of NextState::SetFilter1: begin TempTrkgSpec1.SetTrackingFilterFromSpec(TempTrkgSpec2); if TempTrkgSpec1.FindLast() then NextState := NextState::Split else NextState := NextState::LoosenFilter1; end; NextState::LoosenFilter1: begin if TempTrkgSpec2."Quantity (Base)" > 0 then TempTrkgSpec1.SetTrackingFilterBlank() else begin if TempTrkgSpec2."Serial No." = '' then TempTrkgSpec1.SetRange("Serial No."); if TempTrkgSpec2."Lot No." = '' then TempTrkgSpec1.SetRange("Lot No."); OnBalanceListsOnAfterLoosenFilter1(TempTrkgSpec1, TempTrkgSpec2); end; if TempTrkgSpec1.FindLast() then NextState := NextState::Split else if TempTrkgSpec2."Quantity (Base)" < 0 then begin TempTrkgSpec1.SetRange("Serial No."); TempTrkgSpec1.SetRange("Lot No."); if TempTrkgSpec1.FindLast() then NextState := NextState::Split else NextState := NextState::SetFilter2 end else NextState := NextState::Error; end; NextState::SetFilter2: begin TempTrkgSpec2.SetTrackingFilterFromSpec(TempTrkgSpec1); if TempTrkgSpec2.FindLast() then NextState := NextState::Split else NextState := NextState::LoosenFilter2; end; NextState::LoosenFilter2: begin if TempTrkgSpec1."Quantity (Base)" > 0 then TempTrkgSpec2.SetTrackingFilterBlank() else begin if TempTrkgSpec1."Serial No." = '' then TempTrkgSpec2.SetRange("Serial No."); if TempTrkgSpec1."Lot No." = '' then TempTrkgSpec2.SetRange("Lot No."); OnBalanceListsOnAfterLoosenFilter2(TempTrkgSpec2, TempTrkgSpec1); end; if TempTrkgSpec2.FindLast() then NextState := NextState::Split else NextState := NextState::Error; end; NextState::Split: begin TempTrkgSpec3 := TempTrkgSpec1; TempTrkgSpec4 := TempTrkgSpec2; if Abs(TempTrkgSpec1."Quantity (Base)") = Abs(TempTrkgSpec2."Quantity (Base)") then begin TempTrkgSpec1.Delete(); TempTrkgSpec2.Delete(); TempTrkgSpec1.ClearTrackingFilter(); if TempTrkgSpec1.FindLast() then NextState := NextState::SetFilter2 else begin TempTrkgSpec2.Reset(); if TempTrkgSpec2.FindLast() then NextState := NextState::Error else NextState := NextState::Finish; end; end else if Abs(TempTrkgSpec1."Quantity (Base)") < Abs(TempTrkgSpec2."Quantity (Base)") then begin TempTrkgSpec2.Validate("Quantity (Base)", TempTrkgSpec2."Quantity (Base)" + TempTrkgSpec1."Quantity (Base)"); TempTrkgSpec4.Validate("Quantity (Base)", -TempTrkgSpec1."Quantity (Base)"); TempTrkgSpec1.Delete(); TempTrkgSpec2.Modify(); NextState := NextState::SetFilter1; end else begin TempTrkgSpec1.Validate("Quantity (Base)", TempTrkgSpec1."Quantity (Base)" + TempTrkgSpec2."Quantity (Base)"); TempTrkgSpec3.Validate("Quantity (Base)", -TempTrkgSpec2."Quantity (Base)"); TempTrkgSpec2.Delete(); TempTrkgSpec1.Modify(); NextState := NextState::SetFilter2; end; TempTrkgSpec3."Entry No." := LastEntryNo + 1; TempTrkgSpec4."Entry No." := LastEntryNo + 1; TempTrkgSpec3.Insert(); TempTrkgSpec4.Insert(); LastEntryNo := TempTrkgSpec3."Entry No."; end; NextState::Error: begin IsHandled := false; OnBalanceListsOnBeforeNextStateError(NextState, IsHandled); if not IsHandled then Error(Text001); end; end; until NextState = NextState::Finish; TempTrkgSpec1.Reset(); TempTrkgSpec2.Reset(); TempTrkgSpec3.Reset(); TempTrkgSpec4.Reset(); if TempTrkgSpec3.FindSet() then repeat TempTrkgSpec1 := TempTrkgSpec3; TempTrkgSpec1.Insert(); until TempTrkgSpec3.Next() = 0; if TempTrkgSpec4.FindSet() then repeat TempTrkgSpec2 := TempTrkgSpec4; TempTrkgSpec2.Insert(); until TempTrkgSpec4.Next() = 0; end; local procedure SplitReservEntry(var ReservEntry: Record "Reservation Entry"; var ReservEntry2: Record "Reservation Entry"; TrackingSpecificationExists: Boolean; var FirstSplit: Boolean) Result: Boolean var OldReservEntryQty: Decimal; begin if not TrackingSpecificationExists then if not FirstSplit then exit(false) else begin FirstSplit := false; exit(true); end; TempTrkgSpec1.Reset(); if not TempTrkgSpec1.FindFirst() then exit(false); OnBeforeSplitReservEntry(TempTrkgSpec1, ReservEntry); ReservEntry.CopyTrackingFromSpec(TempTrkgSpec1); OldReservEntryQty := ReservEntry.Quantity; ReservEntry.Validate("Quantity (Base)", TempTrkgSpec1."Quantity (Base)"); if Abs(ReservEntry.Quantity - OldReservEntryQty) <= UOMMgt.QtyRndPrecision() then ReservEntry.Quantity := OldReservEntryQty; TempTrkgSpec1.Delete(); if (ReservEntry."Reservation Status" = ReservEntry."Reservation Status"::Reservation) or (ReservEntry."Reservation Status" = ReservEntry."Reservation Status"::Tracking) then begin TempTrkgSpec2.Get(TempTrkgSpec1."Entry No."); OnBeforeSplitNonSurplusReservEntry(TempTrkgSpec2, ReservEntry); ReservEntry2.CopyTrackingFromSpec(TempTrkgSpec2); OldReservEntryQty := ReservEntry2.Quantity; ReservEntry2.Validate("Quantity (Base)", TempTrkgSpec2."Quantity (Base)"); if Abs(ReservEntry2.Quantity - OldReservEntryQty) <= UOMMgt.QtyRndPrecision() then ReservEntry2.Quantity := OldReservEntryQty; if ReservEntry2.Positive then ReservEntry2."Appl.-from Item Entry" := TempTrkgSpec2."Appl.-from Item Entry"; TempTrkgSpec2.Delete(); end; Result := true; OnAfterSplitReservEntry(ReservEntry2, TempTrkgSpec2, Result); end; local procedure CreateWhseItemTrkgLines(ReservEntry: Record "Reservation Entry") var WhseShipmentLine: Record "Warehouse Shipment Line"; WhseWkshLine: Record "Whse. Worksheet Line"; ReservationEntry: Record "Reservation Entry"; ItemTrackingSetup: Record "Item Tracking Setup"; ItemTrkgMgt: Codeunit "Item Tracking Management"; WhseItemTrkgQtyBase: Decimal; ReservEntryQtyBase: Decimal; begin OnBeforeCreateWhseItemTrkgLines(ReservEntry); WhseShipmentLine.SetSourceFilter( ReservEntry."Source Type", ReservEntry."Source Subtype", ReservEntry."Source ID", ReservEntry."Source Ref. No.", true); if not WhseShipmentLine.FindFirst() then exit; ItemTrackingSetup.CopyTrackingFromReservEntry(ReservEntry); WhseItemTrkgQtyBase := ItemTrkgMgt.CalcWhseItemTrkgLineQtyBase( Database::"Warehouse Shipment Line", 0, WhseShipmentLine."No.", '', 0, WhseShipmentLine."Source Line No.", WhseShipmentLine."Location Code", ItemTrackingSetup); ReservEntry.SetPointerFilter(); ReservationEntry.CopyFilters(ReservEntry); ReservationEntry.SetTrackingFilterFromReservEntry(ReservEntry); ReservationEntry.CalcSums("Quantity (Base)"); ReservEntryQtyBase := Abs(ReservationEntry."Quantity (Base)"); if WhseItemTrkgQtyBase < ReservEntryQtyBase then begin ItemTrkgMgt.InitWhseWorksheetLine(WhseWkshLine, Enum::"Warehouse Worksheet Document Type"::Shipment, WhseShipmentLine."No.", WhseShipmentLine."Line No.", WhseShipmentLine."Source Type", WhseShipmentLine."Source Subtype", WhseShipmentLine."Source No.", WhseShipmentLine."Source Line No.", 0); ItemTrkgMgt.CreateWhseItemTrkgForResEntry(ReservEntry, WhseWkshLine); end; end; procedure SetItemLedgEntryNo(EntryNo: Integer) begin InsertReservEntry."Item Ledger Entry No." := EntryNo; end; procedure SetApplyToEntryNo(EntryNo: Integer) begin InsertReservEntry."Appl.-to Item Entry" := EntryNo; end; procedure SetApplyFromEntryNo(EntryNo: Integer) begin InsertReservEntry."Appl.-from Item Entry" := EntryNo; end; procedure SetOverruleItemTracking(Overrule: Boolean) begin OverruleItemTracking := Overrule; end; procedure SetInbound(NewInbound: Boolean) begin Inbound := NewInbound; end; procedure SetUseQtyToInvoice(UseQtyToInvoice2: Boolean) begin UseQtyToInvoice := UseQtyToInvoice2; end; procedure SetUntrackedSurplus(OrderTracking: Boolean) begin InsertReservEntry."Untracked Surplus" := OrderTracking; InsertReservEntry2."Untracked Surplus" := OrderTracking; end; procedure UpdateItemTrackingAfterPosting(var ReservEntry: Record "Reservation Entry") var CurrSourceRefNo: Integer; ReachedEndOfResvEntries: Boolean; begin OnBeforeUpdateItemTrackingAfterPosting(ReservEntry); if not ReservEntry.FindSet(true) then exit; repeat CurrSourceRefNo := ReservEntry."Source Ref. No."; repeat ReservEntry."Qty. to Handle (Base)" := ReservEntry."Quantity (Base)"; ReservEntry."Qty. to Invoice (Base)" := ReservEntry."Quantity (Base)"; OnUpdateItemTrackingAfterPostingOnBeforeReservEntryModify(ReservEntry); ReservEntry.Modify(); if ReservEntry.Next() = 0 then ReachedEndOfResvEntries := true; until ReachedEndOfResvEntries or (ReservEntry."Source Ref. No." <> CurrSourceRefNo); // iterate over each set of Source Ref No. until ReservEntry."Source Ref. No." = CurrSourceRefNo; end; local procedure SynchronizeTransferOutboundToInboundItemTracking(ReservationEntryNo: Integer) var FromReservationEntry: Record "Reservation Entry"; ToReservationEntry: Record "Reservation Entry"; ItemTrackingManagement: Codeunit "Item Tracking Management"; begin if FromReservationEntry.Get(ReservationEntryNo, false) then if (FromReservationEntry."Source Type" = Database::"Transfer Line") and (FromReservationEntry."Source Subtype" = 0) and FromReservationEntry.TrackingExists() and NeedSynchronizeItemTrackingToOutboundTransfer(FromReservationEntry) then begin ToReservationEntry := FromReservationEntry; ToReservationEntry."Source Subtype" := 1; ItemTrackingManagement.SynchronizeItemTrackingByPtrs(FromReservationEntry, ToReservationEntry); end; end; local procedure NeedSynchronizeItemTrackingToOutboundTransfer(ReservationEntry: Record "Reservation Entry"): Boolean var ItemTrackingMgt: Codeunit "Item Tracking Management"; CurrSourceID: Text; begin CurrSourceID := ItemTrackingMgt.ComposeRowID( ReservationEntry."Source Type", ReservationEntry."Source Subtype", ReservationEntry."Source ID", ReservationEntry."Source Batch Name", ReservationEntry."Source Prod. Order Line", ReservationEntry."Source Ref. No."); if LastProcessedSourceID = CurrSourceID then exit(false); LastProcessedSourceID := CurrSourceID; exit(true); end; internal procedure SetQtyToHandleAndInvoiceForReservationWithoutItemTracking(var ReservationEntry: Record "Reservation Entry"; QtyToHandleBase: Decimal; QtyToInvoiceBase: Decimal; DoModify: Boolean) begin if (ReservationEntry."Item Tracking" = ReservationEntry."Item Tracking"::None) and (ReservationEntry."Reservation Status" = ReservationEntry."Reservation Status"::Reservation) and (ReservationEntry."Qty. to Handle (Base)" = 0) and (ReservationEntry."Qty. to Invoice (Base)" = 0) then begin ReservationEntry."Qty. to Handle (Base)" := QtyToHandleBase; ReservationEntry."Qty. to Invoice (Base)" := QtyToInvoiceBase; if DoModify then ReservationEntry.Modify(); end; end; local procedure ClearNewItemTracking(NewType: Option; NewSubtype: Integer; RemainingQty: Decimal) begin if ((NewType = Database::"Item Journal Line") and (NewSubtype in [3, 5, 6]) or OverruleItemTracking) and (RemainingQty = 0) then if InsertReservEntry.NewTrackingExists() then InsertReservEntry.ClearNewTracking(); end; [IntegrationEvent(false, false)] local procedure OnAfterCheckValidity(ReservEntry: Record "Reservation Entry"; var IsError: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterCheckSourceTypeSubtype(var ReservationEntry: Record "Reservation Entry"; var IsError: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterCopyFromInsertReservEntry(var InsertReservEntry: Record "Reservation Entry"; var ReservEntry: Record "Reservation Entry"; FromReservEntry: Record "Reservation Entry"; Status: Enum "Reservation Status"; var QtyToHandleAndInvoiceIsSet: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterCreateReservEntryFor(var ReservationEntry: Record "Reservation Entry"; Sign: Integer; ForType: Option; ForSubtype: Integer; ForID: Code[20]; ForBatchName: Code[10]; ForProdOrderLine: Integer; ForRefNo: Integer; ForQtyPerUOM: Decimal; Quantity: Decimal; QuantityBase: Decimal; ForReservEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnAfterCreateReservEntryFrom(var ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnAfterSplitReservEntry(var ReservEntry2: Record "Reservation Entry"; TempTrackingSpecificaion: Record "Tracking Specification"; var Result: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterCreateEntry(ItemNo: Code[20]; VariantCode: Code[10]; LocationCode: Code[10]) begin end; [IntegrationEvent(false, false)] local procedure OnAfterReservEntryInsert(var ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnAfterReservEntryInsertNonSurplus(var ReservationEntry2: Record "Reservation Entry"; var ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeSignFactor(var ReservationEntry: Record "Reservation Entry"; Inbound: Boolean; var Sign: Integer) begin end; [IntegrationEvent(false, false)] local procedure OnAfterSignFactor(ReservationEntry: Record "Reservation Entry"; var Sign: Integer) begin end; [IntegrationEvent(false, false)] local procedure OnAfterSetNewTrackingFromItemJnlLine(var InsertReservEntry: Record "Reservation Entry"; ItemJnlLine: Record "Item Journal Line") begin end; [IntegrationEvent(false, false)] local procedure OnAfterSetDates(var ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnAfterSetNewTrackingFromNewTrackingSpecification(var InsertReservEntry: Record "Reservation Entry"; TrackingSpecification: Record "Tracking Specification") begin end; [IntegrationEvent(false, false)] local procedure OnAfterSetNewTrackingFromNewWhseItemTrackingLine(var InsertReservEntry: Record "Reservation Entry"; WhseItemTrackingLine: Record "Whse. Item Tracking Line") begin end; [IntegrationEvent(false, false)] local procedure OnAfterTransferReservEntry(NewReservEntry: Record "Reservation Entry"; OldReservEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBalanceListsOnAfterLoosenFilter1(var TempTrackingSpecification1: Record "Tracking Specification" temporary; TempTrackingSpecification2: Record "Tracking Specification" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnBalanceListsOnAfterLoosenFilter2(var TempTrackingSpecification2: Record "Tracking Specification" temporary; TempTrackingSpecification1: Record "Tracking Specification" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCheckValidity(var ReservationEntry: Record "Reservation Entry"; var IsHandled: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnBeforeClearTracking(var ReservEntry: Record "Reservation Entry"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCreateRemainingReservEntry(var ReservationEntry: Record "Reservation Entry"; FromReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCreateRemainingReservEntryProcedure(var ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCreateRemainingNonSurplusReservEntry(var ReservationEntry: Record "Reservation Entry"; FromReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCreateWhseItemTrkgLines(ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeReservEntryInsert(var ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeReservEntryInsertNonSurplus(var ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeReservEntryUpdateItemTracking(var ReservationEntry: Record "Reservation Entry"; var ReservationEntry2: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeSplitNonSurplusReservEntry(var TempTrackingSpecification: Record "Tracking Specification" temporary; var ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeSplitReservEntry(var TempTrackingSpecification: Record "Tracking Specification" temporary; var ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeUseOldReservEntry(var ReservEntry: Record "Reservation Entry"; var InsertReservEntry: Record "Reservation Entry"; CurrSignFactor: Integer) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeUpdateItemTrackingAfterPosting(var ReservEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnCreateEntryOnAfterCollectTrackingSpecificationTempTrkgSpec2(var TempTrkgSpec2: Record "Tracking Specification" temporary; ReservEntry2: Record "Reservation Entry"; var TrackingSpecificationExists: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreateEntryOnBeforeOnBeforeSplitReservEntry(var ReservEntry: Record "Reservation Entry"; var ReservEntry2: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnCreateEntryOnBeforeSurplusCondition(var ReservEntry: Record "Reservation Entry"; QtyToHandleAndInvoiceIsSet: Boolean; var InsertReservEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnCreateReservEntryExtraFields(var InsertReservEntry: Record "Reservation Entry"; OldTrackingSpecification: Record "Tracking Specification"; NewTrackingSpecification: Record "Tracking Specification") begin end; [IntegrationEvent(false, false)] local procedure OnCreateRemainingReservEntryOnBeforeCreateReservEntryFrom(var ReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnBeforeUpdateItemTracking(var ReservationEntry: Record "Reservation Entry"; CarriedReservationEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnAfterNewReservEntryInsert(var NewReservEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnAfterCalcShouldCreateWhseItemTrkgLines(OldReservEntry: Record "Reservation Entry"; var ShouldCreateWhseItemTrkgLines: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnBeforeNewReservEntryModify(var NewReservEntry: Record "Reservation Entry"; IsPartnerRecord: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnBeforeTransferFields(var OldReservationEntry: Record "Reservation Entry"; var UseQtyToHandle: Boolean; var UseQtyToInvoice: Boolean; var CurrSignFactor: Integer) begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnBeforeCheckCarriedItemTrackingSetupTrackingExists(var NewReservEntry: Record "Reservation Entry"; OldReservEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnNewItemTracking(var NewReservEntry: Record "Reservation Entry"; var InsertReservEntry: Record "Reservation Entry"; TransferQty: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnBeforeCreateRemainingReservEntry(var OldReservationEntry: Record "Reservation Entry"; var NewReservationEntry: Record "Reservation Entry"; TransferQty: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnAfterCreateRemainingReservEntry(OldReservEntry: Record "Reservation Entry"; LastReservEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnAfterCalcNewButUnchangedVersion(var NewReservEntry: Record "Reservation Entry"; OldReservEntry: Record "Reservation Entry"; TransferQty: Decimal; var DoCreateNewButUnchangedVersion: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnBeforeCreateNewReservEntry(var NewReservEntry: Record "Reservation Entry"; OldReservEntry: Record "Reservation Entry"; var IsHandled: Boolean; TransferQty: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateItemTrackingAfterPostingOnBeforeReservEntryModify(var ReservEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnAfterSetQtyToHandleAndInvoice(var InsertReservEntry: Record "Reservation Entry") begin end; [IntegrationEvent(false, false)] local procedure OnBalanceListsOnBeforeNextStateError(var NextState: Option; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreateEntryOnBeforeSplitReservEntryLoop(var ReservEntry: Record "Reservation Entry"; var ReservEntry2: Record "Reservation Entry"; TrackingSpecificationExists: Boolean; var FirstSplit: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnTransferReservEntryOnAfterTransferFields(var NewReservationEntry: Record "Reservation Entry"; var OldReservationEntry: Record "Reservation Entry"; var UseQtyToHandle: Boolean; var UseQtyToInvoice: Boolean; var CurrSignFactor: Integer) begin end; [IntegrationEvent(false, false)] local procedure OnCheckSourceTypeSubtype(var ReservationEntry: Record "Reservation Entry"; var IsError: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCreateEntry(ItemNo: Code[20]; VariantCode: Code[10]; LocationCode: Code[10]; Description: Text[100]; ExpectedReceiptDate: Date; ShipmentDate: Date; TransferredFromEntryNo: Integer; Status: Enum "Reservation Status") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCreateReservEntry(ItemNo: Code[20]; VariantCode: Code[10]; LocationCode: Code[10]; Description: Text[100]; ExpectedReceiptDate: Date; ShipmentDate: Date) begin end;}