Codeunit 99000830 Create Reserv. Entry

Base Application, Microsoft.Inventory.Tracking

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;}