Codeunit 99000832 Sales Line-Reserve

Base Application, Microsoft.Sales.Document

src/Layers/W1/BaseApp/Sales/Document/SalesLineReserve.Codeunit.al2,121 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.Sales.Document;using Microsoft.Foundation.Navigate;using Microsoft.Foundation.UOM;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.Tracking;using Microsoft.Purchases.Document;using Microsoft.Sales.History;using Microsoft.Warehouse.Document;/// <summary>/// Manages item reservations for sales lines including creation, modification, and verification./// </summary>codeunit 99000832 "Sales Line-Reserve"{    Permissions = TableData "Reservation Entry" = rimd,                  TableData "Planning Assignment" = rimd;    trigger OnRun()    begin    end;    var        FromTrackingSpecification: Record "Tracking Specification";        CreateReservEntry: Codeunit "Create Reserv. Entry";        ReservationEngineMgt: Codeunit "Reservation Engine Mgt.";        ReservationManagement: Codeunit "Reservation Management";        ItemTrackingManagement: Codeunit "Item Tracking Management";        UnitOfMeasureManagement: Codeunit "Unit of Measure Management";        Blocked: Boolean;        ApplySpecificItemTracking: Boolean;        OverruleItemTracking: Boolean;        DeleteItemTracking: Boolean;        ItemTrkgAlreadyOverruled: Boolean;        ReservedQtyTooLargeErr: Label 'Reserved quantity cannot be greater than %1.', Comment = '%1: not reserved quantity on Sales Line';        ValueIsEmptyErr: Label 'must be filled in when a quantity is reserved';        ValueNotEmptyErr: Label 'must not be filled in when a quantity is reserved';        ValueChangedErr: Label 'must not be changed when a quantity is reserved';        CodeunitInitErr: Label 'Codeunit is not initialized correctly.';        SalesTxt: Label 'Sales';        SummaryTypeTxt: Label '%1, %2', Locked = true;        SourceDoc3Txt: Label '%1 %2 %3', Locked = true;    /// <summary>    /// Creates a reservation entry for a sales line with the specified tracking and quantity details.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to create the reservation for.</param>    /// <param name="Description">Specifies the description for the reservation entry.</param>    /// <param name="ExpectedReceiptDate">Specifies the expected receipt date for the reservation.</param>    /// <param name="Quantity">Specifies the quantity to reserve.</param>    /// <param name="QuantityBase">Specifies the quantity to reserve in base unit of measure.</param>    /// <param name="ForReservationEntry">Specifies the reservation entry to link the new reservation to.</param>    procedure CreateReservation(SalesLine: Record "Sales Line"; Description: Text[100]; ExpectedReceiptDate: Date; Quantity: Decimal; QuantityBase: Decimal; ForReservationEntry: Record "Reservation Entry")    var        ShipmentDate: Date;        SignFactor: Integer;        IsHandled: Boolean;        DoCreateReservationEntry: Boolean;    begin        IsHandled := false;        OnBeforeCreateReservation(SalesLine, IsHandled);        if IsHandled then            exit;        if FromTrackingSpecification."Source Type" = 0 then            Error(CodeunitInitErr);        SalesLine.TestField(Type, SalesLine.Type::Item);        SalesLine.TestField("No.");        SalesLine.TestField("Shipment Date");        SalesLine.CalcFields("Reserved Qty. (Base)");        IsHandled := false;        OnCreateReservationOnBeforeCheckReservedQty(SalesLine, IsHandled, QuantityBase);        if IsHandled then            exit;        if Abs(SalesLine."Outstanding Qty. (Base)") < Abs(SalesLine."Reserved Qty. (Base)") + QuantityBase then            Error(              ReservedQtyTooLargeErr,              Abs(SalesLine."Outstanding Qty. (Base)") - Abs(SalesLine."Reserved Qty. (Base)"));        IsHandled := false;        OnCreateReservationOnBeforeTestVariantCode(SalesLine, FromTrackingSpecification, IsHandled);        if not IsHandled then            SalesLine.TestField("Variant Code", FromTrackingSpecification."Variant Code");        IsHandled := false;        OnCreateReservationOnBeforeTestLocationCode(SalesLine, FromTrackingSpecification, IsHandled);        if not IsHandled then            SalesLine.TestField("Location Code", FromTrackingSpecification."Location Code");        if SalesLine."Document Type" = SalesLine."Document Type"::"Return Order" then            SignFactor := 1        else            SignFactor := -1;        if QuantityBase * SignFactor < 0 then            ShipmentDate := SalesLine."Shipment Date"        else begin            ShipmentDate := ExpectedReceiptDate;            ExpectedReceiptDate := SalesLine."Shipment Date";        end;        IsHandled := false;        DoCreateReservationEntry := true;        OnCreateReservationOnBeforeCreateReservEntry(SalesLine, Quantity, QuantityBase, ForReservationEntry, IsHandled, FromTrackingSpecification, ExpectedReceiptDate, Description, ShipmentDate, DoCreateReservationEntry);        if not IsHandled then begin            CreateReservEntry.CreateReservEntryFor(                Database::"Sales Line", SalesLine."Document Type".AsInteger(),                SalesLine."Document No.", '', 0, SalesLine."Line No.", SalesLine."Qty. per Unit of Measure",                Quantity, QuantityBase, ForReservationEntry);            CreateReservEntry.CreateReservEntryFrom(FromTrackingSpecification);        end;        if DoCreateReservationEntry then            CreateReservEntry.CreateReservEntry(                SalesLine."No.", SalesLine."Variant Code", SalesLine."Location Code",                Description, ExpectedReceiptDate, ShipmentDate, 0);        FromTrackingSpecification."Source Type" := 0;        OnAfterCreateReservation(SalesLine);    end;    /// <summary>    /// Creates a binding reservation for a sales line without linking to an existing reservation entry.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to create the reservation for.</param>    /// <param name="Description">Specifies the description for the reservation entry.</param>    /// <param name="ExpectedReceiptDate">Specifies the expected receipt date for the reservation.</param>    /// <param name="Quantity">Specifies the quantity to reserve.</param>    /// <param name="QuantityBase">Specifies the quantity to reserve in base unit of measure.</param>    procedure CreateBindingReservation(SalesLine: Record "Sales Line"; Description: Text[100]; ExpectedReceiptDate: Date; Quantity: Decimal; QuantityBase: Decimal)    var        DummyReservationEntry: Record "Reservation Entry";    begin        CreateReservation(SalesLine, Description, ExpectedReceiptDate, Quantity, QuantityBase, DummyReservationEntry);    end;    /// <summary>    /// Sets the tracking specification to use when creating reservation entries.    /// </summary>    /// <param name="TrackingSpecification">Specifies the tracking specification to use as the source.</param>    procedure CreateReservationSetFrom(TrackingSpecification: Record "Tracking Specification")    begin        FromTrackingSpecification := TrackingSpecification;    end;    /// <summary>    /// Sets the binding type for reservation entries to be created.    /// </summary>    /// <param name="Binding">Specifies the reservation binding type.</param>    procedure SetBinding(Binding: Enum "Reservation Binding")    begin        CreateReservEntry.SetBinding(Binding);    end;    /// <summary>    /// Sets whether cancellation of reservation entries is disallowed.    /// </summary>    /// <param name="DisallowCancellation">Specifies whether cancellation is disallowed.</param>    procedure SetDisallowCancellation(DisallowCancellation: Boolean)    begin        CreateReservEntry.SetDisallowCancellation(DisallowCancellation);    end;    /// <summary>    /// Calculates the quantity available for reservation on a sales line.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to calculate reservation quantity for.</param>    /// <param name="QtyToReserve">Returns the quantity available for reservation.</param>    /// <param name="QtyToReserveBase">Returns the quantity available for reservation in base unit of measure.</param>    procedure ReservQuantity(SalesLine: Record "Sales Line"; var QtyToReserve: Decimal; var QtyToReserveBase: Decimal)    begin        case SalesLine."Document Type" of            SalesLine."Document Type"::Quote,            SalesLine."Document Type"::Order,            SalesLine."Document Type"::Invoice,            SalesLine."Document Type"::"Blanket Order":                begin                    QtyToReserve := SalesLine."Outstanding Quantity";                    QtyToReserveBase := SalesLine."Outstanding Qty. (Base)";                end;            SalesLine."Document Type"::"Return Order",            SalesLine."Document Type"::"Credit Memo":                begin                    QtyToReserve := -SalesLine."Outstanding Quantity";                    QtyToReserveBase := -SalesLine."Outstanding Qty. (Base)"                end;        end;        OnAfterReservQuantity(SalesLine, QtyToReserve, QtyToReserveBase);    end;    /// <summary>    /// Returns a caption describing the sales line for reservation purposes.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to get the caption for.</param>    /// <returns>The caption text for the sales line.</returns>    procedure Caption(SalesLine: Record "Sales Line") CaptionText: Text    begin        CaptionText := SalesLine.GetSourceCaption();    end;    /// <summary>    /// Finds the last reservation entry for the specified sales line.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to find reservation entries for.</param>    /// <param name="ReservationEntry">Returns the found reservation entry record.</param>    /// <returns>True if a reservation entry was found, otherwise false.</returns>    procedure FindReservEntry(SalesLine: Record "Sales Line"; var ReservationEntry: Record "Reservation Entry"): Boolean    begin        ReservationEntry.InitSortingAndFilters(false);        SalesLine.SetReservationFilters(ReservationEntry);        exit(ReservationEntry.FindLast());    end;    /// <summary>    /// Calculates the quantity reserved from inventory for a sales line.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to calculate reserved quantity for.</param>    /// <returns>The quantity reserved from inventory in base unit of measure.</returns>    procedure GetReservedQtyFromInventory(SalesLine: Record "Sales Line"): Decimal    var        ReservationEntry: Record "Reservation Entry";        QtyReservedFromItemLedger: Query "Qty. Reserved From Item Ledger";    begin        SalesLine.SetReservationEntry(ReservationEntry);        QtyReservedFromItemLedger.SetSourceFilter(ReservationEntry);        QtyReservedFromItemLedger.Open();        if QtyReservedFromItemLedger.Read() then            exit(QtyReservedFromItemLedger.Quantity__Base_);        exit(0);    end;    /// <summary>    /// Calculates the total quantity reserved from inventory for all lines on a sales header.    /// </summary>    /// <param name="SalesHeader">Specifies the sales header to calculate reserved quantity for.</param>    /// <returns>The total quantity reserved from inventory in base unit of measure.</returns>    procedure GetReservedQtyFromInventory(SalesHeader: Record "Sales Header"): Decimal    var        ReservationEntry: Record "Reservation Entry";        QtyReservedFromItemLedger: Query "Qty. Reserved From Item Ledger";    begin        ReservationEntry.SetSource(Database::"Sales Line", SalesHeader."Document Type".AsInteger(), SalesHeader."No.", 0, '', 0);        QtyReservedFromItemLedger.SetSourceFilter(ReservationEntry);        QtyReservedFromItemLedger.Open();        if QtyReservedFromItemLedger.Read() then            exit(QtyReservedFromItemLedger.Quantity__Base_);        exit(0);    end;    /// <summary>    /// Checks whether a reservation entry exists for the specified sales line.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to check.</param>    /// <returns>True if a reservation entry exists, otherwise false.</returns>    procedure ReservEntryExist(SalesLine: Record "Sales Line"): Boolean    begin        exit(SalesLine.ReservEntryExist());    end;    /// <summary>    /// Verifies and handles changes to a sales line that affect reservations.    /// </summary>    /// <param name="NewSalesLine">Specifies the new version of the sales line.</param>    /// <param name="OldSalesLine">Specifies the original version of the sales line.</param>    procedure VerifyChange(var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line")    var        SalesLine: Record "Sales Line";        ShowError: Boolean;        HasError: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeVerifyChange(NewSalesLine, OldSalesLine, IsHandled);        if IsHandled then            exit;        if (NewSalesLine.Type <> NewSalesLine.Type::Item) and (OldSalesLine.Type <> OldSalesLine.Type::Item) then            exit;        if Blocked then            exit;        if NewSalesLine."Line No." = 0 then            if not SalesLine.Get(                 NewSalesLine."Document Type", NewSalesLine."Document No.", NewSalesLine."Line No.")            then                exit;        NewSalesLine.CalcFields("Reserved Qty. (Base)");        ShowError := NewSalesLine."Reserved Qty. (Base)" <> 0;        HasError := TestSalesLineModification(OldSalesLine, NewSalesLine, ShowError);        OnVerifyChangeOnBeforeHasError(NewSalesLine, OldSalesLine, HasError, ShowError);        if HasError then            ClearReservation(OldSalesLine, NewSalesLine);        if HasError or (NewSalesLine."Shipment Date" <> OldSalesLine."Shipment Date") then begin            AssignForPlanning(NewSalesLine);            if (NewSalesLine."No." <> OldSalesLine."No.") or               (NewSalesLine."Variant Code" <> OldSalesLine."Variant Code") or               (NewSalesLine."Location Code" <> OldSalesLine."Location Code")            then                AssignForPlanning(OldSalesLine);        end;    end;    /// <summary>    /// Verifies and handles quantity changes on a sales line that affect reservations.    /// </summary>    /// <param name="NewSalesLine">Specifies the new version of the sales line.</param>    /// <param name="OldSalesLine">Specifies the original version of the sales line.</param>    procedure VerifyQuantity(var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line")    var        SalesLine: Record "Sales Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeVerifyQuantity(NewSalesLine, IsHandled, OldSalesLine);        if IsHandled then            exit;        if Blocked then            exit;        if NewSalesLine.Type <> NewSalesLine.Type::Item then            exit;        if NewSalesLine."Document Type" = OldSalesLine."Document Type" then            if NewSalesLine."Line No." = OldSalesLine."Line No." then                if NewSalesLine."Quantity (Base)" = OldSalesLine."Quantity (Base)" then                    exit;        if NewSalesLine."Line No." = 0 then            if not SalesLine.Get(NewSalesLine."Document Type", NewSalesLine."Document No.", NewSalesLine."Line No.") then                exit;        ReservationManagement.SetReservSource(NewSalesLine);        DeleteSalesReservEntries(NewSalesLine, OldSalesLine);        ReservationManagement.ClearSurplus();        ReservationManagement.AutoTrack(NewSalesLine."Outstanding Qty. (Base)");        AssignForPlanning(NewSalesLine);    end;    /// <summary>    /// Sets the quantity to ship on a sales line to the outstanding quantity. Called as an action from error handling.    /// </summary>    /// <param name="ErrorInfo">Specifies the error information containing the sales line record ID.</param>    procedure SetSaleShipQty(ErrorInfo: ErrorInfo)    var        CurrSalesLine: Record "Sales Line";    begin        CurrSalesLine.Get(ErrorInfo.RecordId);        CurrSalesLine.Validate("Qty. to Ship", CurrSalesLine."Outstanding Quantity");        CurrSalesLine.Modify(true);    end;    /// <summary>    /// Sets the quantity to invoice on a sales line to the maximum quantity. Called as an action from error handling.    /// </summary>    /// <param name="ErrorInfo">Specifies the error information containing the sales line record ID.</param>    procedure SetSalesQtyInvoice(ErrorInfo: ErrorInfo)    var        CurrSalesLine: Record "Sales Line";    begin        CurrSalesLine.Get(ErrorInfo.RecordId);        CurrSalesLine.Validate("Qty. to Invoice", CurrSalesLine.MaxQtyToInvoice());        CurrSalesLine.Modify(true);    end;    local procedure DeleteSalesReservEntries(var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line")    var        IsHandled: Boolean;        ShouldDeleteAllReservationEntries: Boolean;    begin        IsHandled := false;        OnBeforeDeleteSalesReservEntries(NewSalesLine, OldSalesLine, ReservationManagement, IsHandled);        if IsHandled then            exit;        if NewSalesLine."Qty. per Unit of Measure" <> OldSalesLine."Qty. per Unit of Measure" then            ReservationManagement.ModifyUnitOfMeasure();        ShouldDeleteAllReservationEntries := NewSalesLine."Outstanding Qty. (Base)" * OldSalesLine."Outstanding Qty. (Base)" < 0;        if not ShouldDeleteAllReservationEntries then            ShouldDeleteAllReservationEntries := CheckQuantityReducedOnSalesLine(NewSalesLine, OldSalesLine);        if ShouldDeleteAllReservationEntries then            ReservationManagement.DeleteReservEntries(true, 0)        else            ReservationManagement.DeleteReservEntries(false, NewSalesLine."Outstanding Qty. (Base)");    end;    /// <summary>    /// Transfers reservation entries from a sales line to an item journal line during posting.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to transfer reservations from.</param>    /// <param name="ItemJournalLine">Specifies the item journal line to transfer reservations to.</param>    /// <param name="TransferQty">Specifies the quantity to transfer.</param>    /// <param name="CheckApplFromItemEntry">Specifies whether to check the applies-from item entry. Returns whether further checks are needed.</param>    /// <param name="OnlyILEReservations">Specifies whether to transfer only item ledger entry reservations.</param>    /// <returns>The remaining quantity that was not transferred.</returns>    procedure TransferSalesLineToItemJnlLine(var SalesLine: Record "Sales Line"; var ItemJournalLine: Record "Item Journal Line"; TransferQty: Decimal; var CheckApplFromItemEntry: Boolean; OnlyILEReservations: Boolean): Decimal    var        OldReservationEntry: Record "Reservation Entry";        OppositeReservationEntry: Record "Reservation Entry";        ItemTrackingSetup: Record "Item Tracking Setup";        NotFullyReserved: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTransferSalesLineToItemJnlLine(SalesLine, IsHandled, ItemJournalLine);        if IsHandled then            exit;        if not FindReservEntry(SalesLine, OldReservationEntry) then            exit(TransferQty);        OldReservationEntry.LockTable(); //Lock the entry related to the sales line.        OldReservationEntry.FindLast();        // Handle Item Tracking on drop shipment:        Clear(CreateReservEntry);        if OverruleItemTracking then            if ItemJournalLine.TrackingExists() then begin                CreateReservEntry.SetNewTrackingFromItemJnlLine(ItemJournalLine);                CreateReservEntry.SetOverruleItemTracking(not ItemTrkgAlreadyOverruled);                // Try to match against Item Tracking on the sales order line:                OldReservationEntry.SetTrackingFilterFromItemJnlLine(ItemJournalLine);                if OldReservationEntry.IsEmpty() then                    exit(TransferQty);            end;        IsHandled := false;        OnTransferSalesLineToItemJnlLineOnBeforeItemJournalLineTest(SalesLine, IsHandled, ItemJournalLine, TransferQty);        if not IsHandled then            ItemJournalLine.TestItemFields(SalesLine."No.", SalesLine."Variant Code", SalesLine."Location Code");        if TransferQty = 0 then            exit;        if ItemJournalLine."Invoiced Quantity" <> 0 then            CreateReservEntry.SetUseQtyToInvoice(true);        OnTransferSalesLineToItemJnlLineOnBeforeInitRecordSet(OldReservationEntry);        if ReservationEngineMgt.InitRecordSet(OldReservationEntry) then begin            repeat                IsHandled := false;                OnTransferSalesLineToItemJnlLineOnBeforeOldReservEntryTest(SalesLine, IsHandled, ItemJournalLine);                if not IsHandled then                    OldReservationEntry.TestItemFields(SalesLine."No.", SalesLine."Variant Code", SalesLine."Location Code");                if ApplySpecificItemTracking and (ItemJournalLine."Applies-to Entry" <> 0) then begin                    CreateReservEntry.SetItemLedgEntryNo(ItemJournalLine."Applies-to Entry");                    CheckApplFromItemEntry := false;                end;                if ItemJournalLine."Assemble to Order" then begin                    ItemTrackingSetup.CopyTrackingFromReservEntry(OldReservationEntry);                    OldReservationEntry."Appl.-to Item Entry" := SalesLine.FindOpenATOEntry(ItemTrackingSetup);                end;                if CheckApplFromItemEntry then begin                    if OldReservationEntry."Reservation Status" = OldReservationEntry."Reservation Status"::Reservation then begin                        OppositeReservationEntry.Get(OldReservationEntry."Entry No.", not OldReservationEntry.Positive);                        if OppositeReservationEntry."Source Type" <> Database::"Item Ledger Entry" then                            NotFullyReserved := true;                    end else                        NotFullyReserved := true;                    if OldReservationEntry."Item Tracking" <> OldReservationEntry."Item Tracking"::None then begin                        IsHandled := false;                        OnTransferSalesLineToItemJnlLineOnBeforeApplFromItemEntryTestField(SalesLine, OldReservationEntry, IsHandled, ItemJournalLine);                        if not IsHandled then                            OldReservationEntry.TestField("Appl.-from Item Entry");                        CreateReservEntry.SetApplyFromEntryNo(OldReservationEntry."Appl.-from Item Entry");                        CheckApplFromItemEntry := false;                    end;                end;                IsHandled := false;                OnTransferSalesLineToItemJnlLineOnBeforeTransferReservationEntry(OldReservationEntry, SalesLine, ItemJournalLine, IsHandled);                if not IsHandled then                    if not (ItemJournalLine."Assemble to Order" xor OldReservationEntry."Disallow Cancellation") then                        if not VerifyPickedQtyReservToInventory(OldReservationEntry, SalesLine, TransferQty) then                            if OnlyILEReservations and OppositeReservationEntry.Get(OldReservationEntry."Entry No.", not OldReservationEntry.Positive) then begin                                if OppositeReservationEntry."Source Type" = Database::"Item Ledger Entry" then                                    TransferReservationEntry(TransferQty, ItemJournalLine, OldReservationEntry);                            end else                                TransferReservationEntry(TransferQty, ItemJournalLine, OldReservationEntry);            until (ReservationEngineMgt.NEXTRecord(OldReservationEntry) = 0) or (TransferQty = 0);            CheckApplFromItemEntry := CheckApplFromItemEntry and NotFullyReserved;        end;        exit(TransferQty);    end;    local procedure TransferReservationEntry(var TransferQty: Decimal; var ItemJournalLine: Record "Item Journal Line"; var ReservationEntry: Record "Reservation Entry")    begin        if ItemJournalLine.IsSourceSales() then            TransferQty :=                CreateReservEntry.TransferReservEntry(                    Database::"Item Journal Line", ItemJournalLine."Entry Type".AsInteger(), ItemJournalLine."Document No.",                    ItemJournalLine."Journal Batch Name", 0, ItemJournalLine."Document Line No.",                    ItemJournalLine."Qty. per Unit of Measure", ReservationEntry, TransferQty)        else            TransferQty :=                CreateReservEntry.TransferReservEntry(                    Database::"Item Journal Line", ItemJournalLine."Entry Type".AsInteger(), ItemJournalLine."Journal Template Name",                    ItemJournalLine."Journal Batch Name", 0, ItemJournalLine."Line No.",                    ItemJournalLine."Qty. per Unit of Measure", ReservationEntry, TransferQty);    end;    /// <summary>    /// Transfers reservation entries from one sales line to another. Used when converting quotes or blanket orders to orders.    /// </summary>    /// <param name="OldSalesLine">Specifies the source sales line.</param>    /// <param name="NewSalesLine">Specifies the destination sales line.</param>    /// <param name="TransferQty">Specifies the quantity to transfer.</param>    procedure TransferSaleLineToSalesLine(var OldSalesLine: Record "Sales Line"; var NewSalesLine: Record "Sales Line"; TransferQty: Decimal)    var        OldReservationEntry: Record "Reservation Entry";        ReservationStatus: Enum "Reservation Status";        IsHandled: Boolean;    begin        // Used for sales quote and blanket order when transferred to order        IsHandled := false;        OnBeforeTransferSaleLineToSalesLine(OldSalesLine, NewSalesLine, TransferQty, IsHandled);        if IsHandled then            exit;        if not FindReservEntry(OldSalesLine, OldReservationEntry) then            exit;        OldReservationEntry.Lock();        NewSalesLine.TestItemFields(OldSalesLine."No.", OldSalesLine."Variant Code", OldSalesLine."Location Code");        for ReservationStatus := ReservationStatus::Reservation to ReservationStatus::Prospect do begin            if TransferQty = 0 then                exit;            OldReservationEntry.SetRange("Reservation Status", ReservationStatus);            if OldReservationEntry.FindSet() then                repeat                    OldReservationEntry.TestItemFields(OldSalesLine."No.", OldSalesLine."Variant Code", OldSalesLine."Location Code");                    if (OldReservationEntry."Reservation Status" = OldReservationEntry."Reservation Status"::Prospect) and                       (OldSalesLine."Document Type" in [OldSalesLine."Document Type"::Quote,                                                         OldSalesLine."Document Type"::"Blanket Order"])                    then                        OldReservationEntry."Reservation Status" := OldReservationEntry."Reservation Status"::Surplus;                    IsHandled := false;                    OnTransferSaleLineToSalesLineOnBeforeCalcTransferQty(NewSalesLine, OldReservationEntry, IsHandled);                    if not IsHandled then                        TransferQty :=                            CreateReservEntry.TransferReservEntry(                                Database::"Sales Line",                                NewSalesLine."Document Type".AsInteger(), NewSalesLine."Document No.", '', 0,                                NewSalesLine."Line No.", NewSalesLine."Qty. per Unit of Measure", OldReservationEntry, TransferQty);                until (OldReservationEntry.Next() = 0) or (TransferQty = 0);        end;    end;    /// <summary>    /// Prompts the user to confirm deletion of item tracking when deleting a sales line with reservations.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to check.</param>    /// <returns>True if deletion is confirmed or no reservations exist, otherwise false.</returns>    procedure DeleteLineConfirm(var SalesLine: Record "Sales Line"): Boolean    begin        if not SalesLine.ReservEntryExist() then            exit(true);        if GuiAllowed then            Commit();        ReservationManagement.SetReservSource(SalesLine);        if ReservationManagement.DeleteItemTrackingConfirm() then            DeleteItemTracking := true;        exit(DeleteItemTracking);    end;    /// <summary>    /// Deletes all reservation entries associated with a sales line.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to delete reservations for.</param>    procedure DeleteLine(var SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeDeleteLine(SalesLine, IsHandled);        if not IsHandled then begin            ReservationManagement.SetReservSource(SalesLine);            if DeleteItemTracking then                ReservationManagement.SetItemTrackingHandling(1); // Allow Deletion            ReservationManagement.DeleteReservEntries(true, 0);            DeleteInvoiceSpecFromLine(SalesLine);            SalesLine.CalcFields("Reserved Qty. (Base)");            AssignForPlanning(SalesLine);        end;    end;    /// <summary>    /// Creates or updates a planning assignment for a sales order line.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to create a planning assignment for.</param>    procedure AssignForPlanning(var SalesLine: Record "Sales Line")    var        PlanningAssignment: Record "Planning Assignment";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeAssignForPlanning(SalesLine, IsHandled);        if IsHandled then            exit;        if SalesLine."Document Type" <> SalesLine."Document Type"::Order then            exit;        if SalesLine.Type <> SalesLine.Type::Item then            exit;        if SalesLine."No." <> '' then            PlanningAssignment.ChkAssignOne(SalesLine."No.", SalesLine."Variant Code", SalesLine."Location Code", SalesLine."Shipment Date");    end;    /// <summary>    /// Opens the Item Tracking Lines page for a sales line.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to manage item tracking for.</param>    procedure CallItemTracking(var SalesLine: Record "Sales Line")    var        TrackingSpecification: Record "Tracking Specification";        ItemTrackingLines: Page "Item Tracking Lines";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCallItemTracking(SalesLine, IsHandled);        if IsHandled then            exit;        InitFromSalesLine(TrackingSpecification, SalesLine);        if ((SalesLine."Document Type" = SalesLine."Document Type"::Invoice) and            (SalesLine."Shipment No." <> '')) or           ((SalesLine."Document Type" = SalesLine."Document Type"::"Credit Memo") and            (SalesLine."Return Receipt No." <> ''))        then            ItemTrackingLines.SetRunMode(Enum::"Item Tracking Run Mode"::"Combined Ship/Rcpt");        if SalesLine."Drop Shipment" then begin            ItemTrackingLines.SetRunMode(Enum::"Item Tracking Run Mode"::"Drop Shipment");            if SalesLine."Purchase Order No." <> '' then                ItemTrackingLines.SetSecondSourceRowID(ItemTrackingManagement.ComposeRowID(                    Database::"Purchase Line",                    1, SalesLine."Purchase Order No.", '', 0, SalesLine."Purch. Order Line No."));        end;        ItemTrackingLines.SetSourceSpec(TrackingSpecification, SalesLine."Shipment Date");        ItemTrackingLines.SetInbound(SalesLine.IsInbound());        OnCallItemTrackingOnBeforeItemTrackingLinesRunModal(SalesLine, ItemTrackingLines);        ItemTrackingLines.RunModal();    end;    /// <summary>    /// Opens the Item Tracking Lines page for a sales line with a second source quantity array.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to manage item tracking for.</param>    /// <param name="SecondSourceQuantityArray">Specifies the second source quantity array for tracking.</param>    procedure CallItemTracking(var SalesLine: Record "Sales Line"; SecondSourceQuantityArray: array[3] of Decimal)    begin        CallItemTrackingSecondSource(SalesLine, SecondSourceQuantityArray, false);    end;    /// <summary>    /// Opens the Item Tracking Lines page for a sales line with a second source and assembly-to-order option.    /// </summary>    /// <param name="SalesLine">Specifies the sales line to manage item tracking for.</param>    /// <param name="SecondSourceQuantityArray">Specifies the second source quantity array for tracking.</param>    /// <param name="AsmToOrder">Specifies whether this is an assemble-to-order scenario.</param>    procedure CallItemTrackingSecondSource(var SalesLine: Record "Sales Line"; SecondSourceQuantityArray: array[3] of Decimal; AsmToOrder: Boolean)    var        TrackingSpecification: Record "Tracking Specification";        ItemTrackingLines: Page "Item Tracking Lines";        IsHandled: Boolean;    begin        if SecondSourceQuantityArray[1] = Database::"Warehouse Shipment Line" then            ItemTrackingLines.SetSecondSourceID(Database::"Warehouse Shipment Line", AsmToOrder);        InitFromSalesLine(TrackingSpecification, SalesLine);        if SecondSourceQuantityArray[1] = Database::"Warehouse Shipment Line" then            TrackingSpecification."Bin Code" := '';        IsHandled := false;        OnCallItemTrackingSecondSourceOnBeforeOpenItemTrackingLines(SalesLine, TrackingSpecification, SecondSourceQuantityArray, IsHandled);        if not IsHandled then begin            ItemTrackingLines.SetSourceSpec(TrackingSpecification, SalesLine."Shipment Date");            ItemTrackingLines.SetSecondSourceQuantity(SecondSourceQuantityArray);            OnCallItemTrackingSecondSourceOnBeforeItemTrackingLinesRun(SalesLine, ItemTrackingLines);            ItemTrackingLines.RunModal();        end;    end;    /// <summary>    /// Retrieves the invoice specification tracking data for a sales line.    /// </summary>    /// <param name="SalesLine">The sales line to retrieve specification for.</param>    /// <param name="TempInvoicingTrackingSpecification">Returns the temporary tracking specification records.</param>    /// <returns>True if specifications were found.</returns>    procedure RetrieveInvoiceSpecification(var SalesLine: Record "Sales Line"; var TempInvoicingTrackingSpecification: Record "Tracking Specification" temporary) OK: Boolean    var        SourceTrackingSpecification: Record "Tracking Specification";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRetrieveInvoiceSpecification(SalesLine, OK, IsHandled, TempInvoicingTrackingSpecification);        if IsHandled then            exit;        Clear(TempInvoicingTrackingSpecification);        if SalesLine.Type <> SalesLine.Type::Item then            exit;        if ((SalesLine."Document Type" = SalesLine."Document Type"::Invoice) and            (SalesLine."Shipment No." <> '')) or           ((SalesLine."Document Type" = SalesLine."Document Type"::"Credit Memo") and            (SalesLine."Return Receipt No." <> ''))        then            OK := RetrieveInvoiceSpecification2(SalesLine, TempInvoicingTrackingSpecification)        else begin            InitFromSalesLine(SourceTrackingSpecification, SalesLine);            OK := ItemTrackingManagement.RetrieveInvoiceSpecification(SourceTrackingSpecification, TempInvoicingTrackingSpecification);        end;    end;    /// <summary>    /// Retrieves invoice specification for combined shipment or return scenarios.    /// </summary>    /// <param name="SalesLine">The sales line to retrieve specification for.</param>    /// <param name="TempInvoicingTrackingSpecification">Returns the temporary tracking specification records.</param>    /// <returns>True if specifications were found.</returns>    procedure RetrieveInvoiceSpecification2(var SalesLine: Record "Sales Line"; var TempInvoicingTrackingSpecification: Record "Tracking Specification" temporary) OK: Boolean    var        TrackingSpecification: Record "Tracking Specification";        ReservationEntry: Record "Reservation Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRetrieveInvoiceSpecification2(SalesLine, OK, IsHandled);        if IsHandled then            exit;        // Used for combined shipment/return:        if SalesLine.Type <> SalesLine.Type::Item then            exit;        if not FindReservEntry(SalesLine, ReservationEntry) then            exit;        ReservationEntry.FindSet();        repeat            ReservationEntry.TestField("Reservation Status", ReservationEntry."Reservation Status"::Prospect);            ReservationEntry.TestField("Item Ledger Entry No.");            TrackingSpecification.Get(ReservationEntry."Item Ledger Entry No.");            TempInvoicingTrackingSpecification := TrackingSpecification;            TempInvoicingTrackingSpecification."Qty. to Invoice (Base)" := ReservationEntry."Qty. to Invoice (Base)";            TempInvoicingTrackingSpecification."Qty. to Invoice" :=              Round(ReservationEntry."Qty. to Invoice (Base)" / ReservationEntry."Qty. per Unit of Measure", UnitOfMeasureManagement.QtyRndPrecision());            TempInvoicingTrackingSpecification."Buffer Status" := TempInvoicingTrackingSpecification."Buffer Status"::MODIFY;            OnRetrieveInvoiceSpecificationOnBeforeInsert(TempInvoicingTrackingSpecification, ReservationEntry);            TempInvoicingTrackingSpecification.Insert();            ReservationEntry.Delete();        until ReservationEntry.Next() = 0;        OK := TempInvoicingTrackingSpecification.FindFirst();    end;    /// <summary>    /// Deletes invoice specifications for all lines in a sales header.    /// </summary>    /// <param name="SalesHeader">The sales header whose specifications to delete.</param>    procedure DeleteInvoiceSpecFromHeader(var SalesHeader: Record "Sales Header")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeDeleteInvoiceSpecFromHeader(SalesHeader, IsHandled);        if IsHandled then            exit;        ItemTrackingManagement.DeleteInvoiceSpecFromHeader(          Database::"Sales Line", SalesHeader."Document Type".AsInteger(), SalesHeader."No.");    end;    local procedure DeleteInvoiceSpecFromLine(var SalesLine: Record "Sales Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeDeleteInvoiceSpecFromLine(SalesLine, IsHandled);        if IsHandled then            exit;        ItemTrackingManagement.DeleteInvoiceSpecFromLine(          Database::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.");    end;    /// <summary>    /// Updates item tracking quantities after posting a sales document.    /// </summary>    /// <param name="SalesHeader">The sales header that was posted.</param>    procedure UpdateItemTrackingAfterPosting(SalesHeader: Record "Sales Header")    var        ReservationEntry: Record "Reservation Entry";    begin        // Used for updating Quantity to Handle and Quantity to Invoice after posting        ReservationEntry.Reset();        ReservationEntry.SetSourceFilter(Database::"Sales Line", SalesHeader."Document Type".AsInteger(), SalesHeader."No.", -1, true);        ReservationEntry.SetSourceFilter('', 0);        CreateReservEntry.UpdateItemTrackingAfterPosting(ReservationEntry);    end;    /// <summary>    /// Sets whether to apply specific item tracking when reserving.    /// </summary>    /// <param name="ApplySpecific">Whether to apply specific item tracking.</param>    procedure SetApplySpecificItemTracking(ApplySpecific: Boolean)    begin        ApplySpecificItemTracking := ApplySpecific;    end;    /// <summary>    /// Sets whether to overrule existing item tracking during reservation.    /// </summary>    /// <param name="Overrule">Whether to overrule item tracking.</param>    procedure SetOverruleItemTracking(Overrule: Boolean)    begin        OverruleItemTracking := Overrule;    end;    /// <summary>    /// Sets the blocked state for reservation operations.    /// </summary>    /// <param name="SetBlocked">Whether to block reservation operations.</param>    procedure Block(SetBlocked: Boolean)    begin        Blocked := SetBlocked;    end;    /// <summary>    /// Sets whether item tracking has already been overruled.    /// </summary>    /// <param name="HasBeenOverruled">Whether item tracking has been overruled.</param>    procedure SetItemTrkgAlreadyOverruled(HasBeenOverruled: Boolean)    begin        ItemTrkgAlreadyOverruled := HasBeenOverruled;    end;    local procedure VerifyPickedQtyReservToInventory(OldReservationEntry: Record "Reservation Entry"; SalesLine: Record "Sales Line"; TransferQty: Decimal): Boolean    var        WarehouseShipmentLine: Record "Warehouse Shipment Line";        NewReservationEntry: Record "Reservation Entry";    begin        if not WarehouseShipmentLine.ReadPermission then            exit(false);        WarehouseShipmentLine.SetSourceFilter(Database::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.", false);        WarehouseShipmentLine.SetRange(Status, WarehouseShipmentLine.Status::"Partially Picked");        exit            (WarehouseShipmentLine.FindFirst() and NewReservationEntry.Get(OldReservationEntry."Entry No.", not OldReservationEntry.Positive) and            (OldReservationEntry."Reservation Status" = OldReservationEntry."Reservation Status"::Reservation) and            (NewReservationEntry."Source Type" <> Database::"Item Ledger Entry") and (WarehouseShipmentLine."Qty. Picked (Base)" >= TransferQty));    end;    /// <summary>    /// Binds a sales line to item tracking with order-to-order binding.    /// </summary>    /// <param name="SalesLine">The sales line to bind.</param>    /// <param name="TrackingSpecification">The tracking specification to bind to.</param>    /// <param name="Description">The reservation description.</param>    /// <param name="ExpectedDate">The expected date for the reservation.</param>    /// <param name="ReservQty">The quantity to reserve.</param>    /// <param name="ReservQtyBase">The quantity to reserve in base unit of measure.</param>    procedure BindToTracking(SalesLine: Record "Sales Line"; TrackingSpecification: Record "Tracking Specification"; Description: Text[100]; ExpectedDate: Date; ReservQty: Decimal; ReservQtyBase: Decimal)    begin        SetBinding("Reservation Binding"::"Order-to-Order");        CreateReservationSetFrom(TrackingSpecification);        CreateBindingReservation(SalesLine, Description, ExpectedDate, ReservQty, ReservQtyBase);    end;    local procedure CheckItemNo(var SalesLine: Record "Sales Line"): Boolean    var        ReservationEntry: Record "Reservation Entry";    begin        ReservationEntry.SetFilter("Item No.", '<>%1', SalesLine."No.");        ReservationEntry.SetRange("Source Type", Database::"Sales Line");        ReservationEntry.SetRange("Source Subtype", SalesLine."Document Type");        ReservationEntry.SetRange("Source ID", SalesLine."Document No.");        ReservationEntry.SetRange("Source Ref. No.", SalesLine."Line No.");        exit(ReservationEntry.IsEmpty);    end;    local procedure ClearReservation(OldSalesLine: Record "Sales Line"; NewSalesLine: Record "Sales Line")    var        DummyReservationEntry: Record "Reservation Entry";    begin        if (NewSalesLine."No." <> OldSalesLine."No.") or FindReservEntry(NewSalesLine, DummyReservationEntry) then begin            if (NewSalesLine."No." <> OldSalesLine."No.") or (NewSalesLine.Type <> OldSalesLine.Type) then begin                ReservationManagement.SetReservSource(OldSalesLine);                ReservationManagement.DeleteReservEntries(true, 0);                ReservationManagement.SetReservSource(NewSalesLine);            end else begin                ReservationManagement.SetReservSource(NewSalesLine);                ReservationManagement.DeleteReservEntries(true, 0);            end;            ReservationManagement.AutoTrack(NewSalesLine."Outstanding Qty. (Base)");        end;    end;    local procedure TestSalesLineModification(OldSalesLine: Record "Sales Line"; NewSalesLine: Record "Sales Line"; ThrowError: Boolean) HasError: Boolean    var        IsHandled: Boolean;    begin        if (NewSalesLine."Shipment Date" = 0D) and (OldSalesLine."Shipment Date" <> 0D) then begin            if ThrowError then                NewSalesLine.FieldError("Shipment Date", ValueIsEmptyErr);            HasError := true;        end;        OnTestSalesLineModificationOnBeforeTestJobNo(NewSalesLine, IsHandled);        if not IsHandled then            if NewSalesLine."Job No." <> '' then begin                if ThrowError then                    NewSalesLine.FieldError("Job No.", ValueNotEmptyErr);                HasError := true;            end;        if NewSalesLine."Purchase Order No." <> '' then begin            if ThrowError then                NewSalesLine.FieldError("Purchase Order No.", ValueNotEmptyErr);            HasError := NewSalesLine."Purchase Order No." <> OldSalesLine."Purchase Order No.";        end;        if NewSalesLine."Purch. Order Line No." <> 0 then begin            if ThrowError then                NewSalesLine.FieldError("Purch. Order Line No.", ValueNotEmptyErr);            HasError := NewSalesLine."Purch. Order Line No." <> OldSalesLine."Purch. Order Line No.";        end;        if NewSalesLine."Drop Shipment" and not OldSalesLine."Drop Shipment" then begin            if ThrowError then                NewSalesLine.FieldError("Drop Shipment", ValueNotEmptyErr);            HasError := true;        end;        if NewSalesLine."Special Order" and not OldSalesLine."Special Order" then begin            if ThrowError then                NewSalesLine.FieldError("Special Order", ValueNotEmptyErr);            HasError := true;        end;        if (NewSalesLine."No." <> OldSalesLine."No.") and not CheckItemNo(NewSalesLine) then begin            if ThrowError then                NewSalesLine.FieldError("No.", ValueChangedErr);            HasError := true;        end;        IsHandled := false;        OnTestSalesLineModificationOnBeforeTestVariantCode(NewSalesLine, OldSalesLine, IsHandled, HasError, ThrowError);        if not IsHandled then            if NewSalesLine."Variant Code" <> OldSalesLine."Variant Code" then begin                if ThrowError then                    NewSalesLine.FieldError("Variant Code", ValueChangedErr);                HasError := true;            end;        IsHandled := false;        OnTestSalesLineModificationOnBeforeTestLocationCode(NewSalesLine, OldSalesLine, IsHandled, HasError);        if not IsHandled then            if NewSalesLine."Location Code" <> OldSalesLine."Location Code" then begin                if ThrowError then                    NewSalesLine.FieldError("Location Code", ValueChangedErr);                HasError := true;            end;        IsHandled := false;        OnTestSalesLineModificationOnBeforeTestBinCode(NewSalesLine, OldSalesLine, IsHandled);        if not IsHandled then            if (OldSalesLine.Type = OldSalesLine.Type::Item) and (NewSalesLine.Type = NewSalesLine.Type::Item) then                if (NewSalesLine."Bin Code" <> OldSalesLine."Bin Code") and                (not ReservationManagement.CalcIsAvailTrackedQtyInBin(                    NewSalesLine."No.", NewSalesLine."Bin Code",                    NewSalesLine."Location Code", NewSalesLine."Variant Code",                    Database::"Sales Line", NewSalesLine."Document Type".AsInteger(),                    NewSalesLine."Document No.", '', 0, NewSalesLine."Line No."))                then begin                    if ThrowError then                        NewSalesLine.FieldError("Bin Code", ValueChangedErr);                    HasError := true;                end;        if NewSalesLine."Line No." <> OldSalesLine."Line No." then            HasError := true;        if NewSalesLine.Type <> OldSalesLine.Type then            HasError := true;    end;    /// <summary>    /// Deletes a sales line along with its item tracking entries.    /// </summary>    /// <param name="SalesLine">The sales line to delete.</param>    procedure DeleteLineWithItemTracking(var SalesLine: Record "Sales Line")    begin        DeleteItemTracking := true;        DeleteLine(SalesLine);    end;    /// <summary>    /// Sets whether to delete item tracking when deleting lines.    /// </summary>    /// <param name="NewDeleteItemTracking">Whether to delete item tracking.</param>    procedure SetDeleteItemTracking(NewDeleteItemTracking: Boolean)    begin        DeleteItemTracking := NewDeleteItemTracking    end;    /// <summary>    /// Copies reservation entries from a sales line to a temporary table.    /// </summary>    /// <param name="TempReservationEntry">The temporary table to copy entries to.</param>    /// <param name="OldSalesLine">The sales line whose reservations to copy.</param>    procedure CopyReservEntryToTemp(var TempReservationEntry: Record "Reservation Entry" temporary; OldSalesLine: Record "Sales Line")    var        ReservationEntry: Record "Reservation Entry";    begin        ReservationEntry.Reset();        ReservationEntry.SetSourceFilter(          Database::"Sales Line", OldSalesLine."Document Type".AsInteger(), OldSalesLine."Document No.", OldSalesLine."Line No.", true);        if ReservationEntry.FindSet() then            repeat                TempReservationEntry := ReservationEntry;                TempReservationEntry.Insert();            until ReservationEntry.Next() = 0;        ReservationEntry.DeleteAll();    end;    /// <summary>    /// Copies reservation entries from a temporary table back to the database with a new source reference.    /// </summary>    /// <param name="TempReservationEntry">The temporary table containing the reservations.</param>    /// <param name="OldSalesLine">The original sales line reference.</param>    /// <param name="NewSourceRefNo">The new source reference number (line number).</param>    procedure CopyReservEntryFromTemp(var TempReservationEntry: Record "Reservation Entry" temporary; OldSalesLine: Record "Sales Line"; NewSourceRefNo: Integer)    var        ReservationEntry: Record "Reservation Entry";    begin        TempReservationEntry.Reset();        TempReservationEntry.SetSourceFilter(          Database::"Sales Line", OldSalesLine."Document Type".AsInteger(), OldSalesLine."Document No.", OldSalesLine."Line No.", true);        if TempReservationEntry.FindSet() then            repeat                ReservationEntry := TempReservationEntry;                ReservationEntry."Source Ref. No." := NewSourceRefNo;                ReservationEntry.Insert();            until TempReservationEntry.Next() = 0;        TempReservationEntry.DeleteAll();    end;    [EventSubscriber(ObjectType::Page, PAGE::Reservation, 'OnGetQtyPerUOMFromSourceRecRef', '', false, false)]    local procedure OnGetQtyPerUOMFromSourceRecRef(SourceRecRef: RecordRef; var QtyPerUOM: Decimal; var QtyReserved: Decimal; var QtyReservedBase: Decimal; var QtyToReserve: Decimal; var QtyToReserveBase: Decimal)    var        SalesLine: Record "Sales Line";    begin        if MatchThisTable(SourceRecRef.Number) then begin            SourceRecRef.SetTable(SalesLine);            SalesLine.Find();            QtyPerUOM := SalesLine.GetReservationQty(QtyReserved, QtyReservedBase, QtyToReserve, QtyToReserveBase);        end;    end;    local procedure SetReservSourceFor(SourceRecordRef: RecordRef; var ReservationEntry: Record "Reservation Entry"; var CaptionText: Text)    var        SalesLine: Record "Sales Line";    begin        SourceRecordRef.SetTable(SalesLine);        TestSourceTableFields(SalesLine);        SalesLine.SetReservationEntry(ReservationEntry);        CaptionText := SalesLine.GetSourceCaption();    end;    local procedure TestSourceTableFields(SalesLine: Record "Sales Line")    begin        SalesLine.TestField("Job No.", '');        SalesLine.TestField("Drop Shipment", false);        SalesLine.TestField(Type, SalesLine.Type::Item);        SalesLine.TestField("Shipment Date");        OnAfterTestSourceTableFields(SalesLine);    end;    /// <summary>    /// Raised after testing source table fields for the sales line during reservation validation.    /// </summary>    /// <param name="SalesLine">The sales line that was validated.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterTestSourceTableFields(SalesLine: Record "Sales Line")    begin    end;    local procedure EntryStartNo(): Integer    begin        exit(Enum::"Reservation Summary Type"::"Sales Quote".AsInteger());    end;    local procedure MatchThisEntry(EntryNo: Integer): Boolean    begin        exit(EntryNo in [Enum::"Reservation Summary Type"::"Sales Quote".AsInteger() ..                         Enum::"Reservation Summary Type"::"Sales Return Order".AsInteger()]);    end;    local procedure MatchThisTable(TableID: Integer): Boolean    begin        exit(TableID = Database::"Sales Line");    end;    [EventSubscriber(ObjectType::Page, Page::Reservation, 'OnSetReservSource', '', false, false)]    local procedure OnSetReservSource(SourceRecRef: RecordRef; var ReservEntry: Record "Reservation Entry"; var CaptionText: Text)    begin        if MatchThisTable(SourceRecRef.Number) then            SetReservSourceFor(SourceRecRef, ReservEntry, CaptionText);    end;    [EventSubscriber(ObjectType::Page, Page::Reservation, 'OnDrillDownTotalQuantity', '', false, false)]    local procedure ReservationOnDrillDownTotalQuantity(SourceRecRef: RecordRef; ReservEntry: Record "Reservation Entry"; EntrySummary: Record "Entry Summary"; Location: Record Location; MaxQtyToReserve: Decimal)    var        AvailableSalesLines: page "Available - Sales Lines";    begin        if MatchThisEntry(EntrySummary."Entry No.") then begin            Clear(AvailableSalesLines);            AvailableSalesLines.SetCurrentSubType(EntrySummary."Entry No." - EntryStartNo());            AvailableSalesLines.SetSource(SourceRecRef, ReservEntry, ReservEntry.GetTransferDirection());            AvailableSalesLines.RunModal();        end;    end;    [EventSubscriber(ObjectType::Page, Page::Reservation, 'OnFilterReservEntry', '', false, false)]    local procedure OnFilterReservEntry(var FilterReservEntry: Record "Reservation Entry"; ReservEntrySummary: Record "Entry Summary")    begin        if MatchThisEntry(ReservEntrySummary."Entry No.") then begin            FilterReservEntry.SetRange("Source Type", DATABASE::"Sales Line");            FilterReservEntry.SetRange("Source Subtype", ReservEntrySummary."Entry No." - EntryStartNo());        end;    end;    [EventSubscriber(ObjectType::Page, Page::Reservation, 'OnAfterRelatesToSummEntry', '', false, false)]    local procedure OnRelatesToEntrySummary(var FilterReservEntry: Record "Reservation Entry"; FromEntrySummary: Record "Entry Summary"; var IsHandled: Boolean)    begin        if MatchThisEntry(FromEntrySummary."Entry No.") then            IsHandled :=                (FilterReservEntry."Source Type" = DATABASE::"Sales Line") and                (FilterReservEntry."Source Subtype" = FromEntrySummary."Entry No." - EntryStartNo());    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Item Ledger Entry-Reserve", 'OnDrillDownTotalQuantity', '', false, false)]    local procedure ItemLedgerEntryOnDrillDownTotalQuantity(SourceRecRef: RecordRef; EntrySummary: Record "Entry Summary" temporary; ReservEntry: Record "Reservation Entry"; Location: Record Location; MaxQtyToReserve: Decimal; var IsHandled: Boolean; sender: Codeunit "Item Ledger Entry-Reserve")    var        CheckOutbound: Boolean;    begin        if MatchThisTable(ReservEntry."Source Type") then begin            CheckOutbound := Location."Bin Mandatory" or Location."Require Pick";            sender.DrillDownTotalQuantity(SourceRecRef, EntrySummary, ReservEntry, MaxQtyToReserve, CheckOutbound, true);            IsHandled := true;        end;    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnCreateReservation', '', false, false)]    local procedure OnCreateReservation(SourceRecRef: RecordRef; TrackingSpecification: Record "Tracking Specification"; ForReservEntry: Record "Reservation Entry"; Description: Text[100]; ExpectedDate: Date; Quantity: Decimal; QuantityBase: Decimal)    var        SalesLine: Record "Sales Line";    begin        if MatchThisTable(ForReservEntry."Source Type") then begin            CreateReservationSetFrom(TrackingSpecification);            SourceRecRef.SetTable(SalesLine);            OnCreateReservationOnBeforeCreateReservation(SalesLine, TrackingSpecification, Description, ExpectedDate, Quantity, QuantityBase, ForReservEntry);            CreateReservation(SalesLine, Description, ExpectedDate, Quantity, QuantityBase, ForReservEntry);        end;    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnLookupDocument', '', false, false)]    local procedure OnLookupDocument(SourceType: Integer; SourceSubtype: Integer; SourceID: Code[20])    var        SalesHeader: Record "Sales Header";    begin        if MatchThisTable(SourceType) then begin            SalesHeader.Reset();            SalesHeader.SetRange("Document Type", SourceSubtype);            SalesHeader.SetRange("No.", SourceID);            case SourceSubtype of                0:                    PAGE.RunModal(PAGE::"Sales Quote", SalesHeader);                1:                    PAGE.RunModal(PAGE::"Sales Order", SalesHeader);                2:                    PAGE.RunModal(PAGE::"Sales Invoice", SalesHeader);                3:                    PAGE.RunModal(PAGE::"Sales Credit Memo", SalesHeader);                5:                    PAGE.RunModal(PAGE::"Sales Return Order", SalesHeader);            end;        end;    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnLookupLine', '', false, false)]    local procedure OnLookupLine(SourceType: Integer; SourceSubtype: Integer; SourceID: Code[20]; SourceRefNo: Integer)    var        SalesLine: Record "Sales Line";    begin        if MatchThisTable(SourceType) then begin            SalesLine.Reset();            SalesLine.SetRange("Document Type", SourceSubtype);            SalesLine.SetRange("Document No.", SourceID);            SalesLine.SetRange("Line No.", SourceRefNo);            PAGE.Run(PAGE::"Sales Lines", SalesLine);        end;    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnFilterReservFor', '', false, false)]    local procedure OnFilterReservFor(SourceRecRef: RecordRef; var ReservEntry: Record "Reservation Entry"; var CaptionText: Text)    var        SalesLine: Record "Sales Line";    begin        if MatchThisTable(SourceRecRef.Number) then begin            SourceRecRef.SetTable(SalesLine);            SalesLine.SetReservationFilters(ReservEntry);            CaptionText := SalesLine.GetSourceCaption();        end;    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnCalculateRemainingQty', '', false, false)]    local procedure OnCalculateRemainingQty(SourceRecRef: RecordRef; var ReservEntry: Record "Reservation Entry"; var RemainingQty: Decimal; var RemainingQtyBase: Decimal)    var        SalesLine: Record "Sales Line";    begin        if MatchThisTable(ReservEntry."Source Type") then begin            SourceRecRef.SetTable(SalesLine);            SalesLine.GetRemainingQty(RemainingQty, RemainingQtyBase);        end;    end;    local procedure GetSourceValue(ReservationEntry: Record "Reservation Entry"; var SourceRecordRef: RecordRef; ReturnOption: Option "Net Qty. (Base)","Gross Qty. (Base)"): Decimal    var        SalesLine: Record "Sales Line";    begin        SalesLine.Get(ReservationEntry."Source Subtype", ReservationEntry."Source ID", ReservationEntry."Source Ref. No.");        SourceRecordRef.GetTable(SalesLine);        case ReturnOption of            ReturnOption::"Net Qty. (Base)":                exit(SalesLine."Outstanding Qty. (Base)");            ReturnOption::"Gross Qty. (Base)":                exit(SalesLine."Quantity (Base)");        end;    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnGetSourceRecordValue', '', false, false)]    local procedure OnGetSourceRecordValue(var ReservEntry: Record "Reservation Entry"; ReturnOption: Option; var ReturnQty: Decimal; var SourceRecRef: RecordRef)    begin        if MatchThisTable(ReservEntry."Source Type") then            ReturnQty := GetSourceValue(ReservEntry, SourceRecRef, ReturnOption);    end;    local procedure UpdateStatistics(ReservationEntry: Record "Reservation Entry"; var TempEntrySummary: Record "Entry Summary" temporary; AvailabilityDate: Date; DocumentType: Enum "Sales Document Type"; Positive: Boolean; var TotalQuantity: Decimal)    var        SalesLine: Record "Sales Line";        AvailabilityFilter: Text;    begin        if not SalesLine.ReadPermission then            exit;        SalesLine.SetAutoCalcFields("Reserved Qty. (Base)");        AvailabilityFilter := ReservationEntry.GetAvailabilityFilter(AvailabilityDate, Positive);        SalesLine.FilterLinesForReservation(ReservationEntry, DocumentType, AvailabilityFilter, Positive);        if SalesLine.FindSet() then            repeat                TempEntrySummary."Total Reserved Quantity" -= SalesLine."Reserved Qty. (Base)";                TotalQuantity += SalesLine."Outstanding Qty. (Base)";            until SalesLine.Next() = 0;        if TotalQuantity = 0 then            exit;        if (Positive = (TotalQuantity < 0)) and (DocumentType <> SalesLine."Document Type"::"Return Order") or            (Positive = (TotalQuantity > 0)) and (DocumentType = SalesLine."Document Type"::"Return Order")        then begin            TempEntrySummary."Table ID" := DATABASE::"Sales Line";            TempEntrySummary."Summary Type" :=                CopyStr(StrSubstNo(SummaryTypeTxt, SalesLine.TableCaption(), SalesLine."Document Type"),                1, MaxStrLen(TempEntrySummary."Summary Type"));            if DocumentType = SalesLine."Document Type"::"Return Order" then                TempEntrySummary."Total Quantity" := TotalQuantity            else                TempEntrySummary."Total Quantity" := -TotalQuantity;            TempEntrySummary."Total Available Quantity" := TempEntrySummary."Total Quantity" - TempEntrySummary."Total Reserved Quantity";            if not TempEntrySummary.Insert() then                TempEntrySummary.Modify();        end;    end;    [EventSubscriber(ObjectType::Page, Page::"Reservation Entries", 'OnLookupReserved', '', false, false)]    local procedure OnLookupReserved(var ReservationEntry: Record "Reservation Entry")    begin        if MatchThisTable(ReservationEntry."Source Type") then            ShowSourceLines(ReservationEntry);    end;    local procedure ShowSourceLines(var ReservationEntry: Record "Reservation Entry")    var        SalesLine: Record "Sales Line";    begin        SalesLine.Reset();        SalesLine.SetRange("Document Type", ReservationEntry."Source Subtype");        SalesLine.SetRange("Document No.", ReservationEntry."Source ID");        SalesLine.SetRange("Line No.", ReservationEntry."Source Ref. No.");        PAGE.RunModal(PAGE::"Sales Lines", SalesLine);    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnUpdateStatistics', '', false, false)]    local procedure OnUpdateStatistics(CalcReservEntry: Record "Reservation Entry"; var ReservSummEntry: Record "Entry Summary"; AvailabilityDate: Date; Positive: Boolean; var TotalQuantity: Decimal)    begin        if ReservSummEntry."Entry No." in [Enum::"Reservation Summary Type"::"Sales Order".AsInteger(),                                           Enum::"Reservation Summary Type"::"Sales Return Order".AsInteger()] then            UpdateStatistics(                CalcReservEntry, ReservSummEntry, AvailabilityDate, Enum::"Sales Document Type".FromInteger(ReservSummEntry."Entry No." - 31), Positive, TotalQuantity);    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnAfterAutoReserveOneLine', '', false, false)]    local procedure OnAfterAutoReserveOneLine(ReservSummEntryNo: Integer; var RemainingQtyToReserve: Decimal; var RemainingQtyToReserveBase: Decimal; Description: Text[100]; AvailabilityDate: Date; Search: Text[1]; NextStep: Integer; CalcReservEntry: Record "Reservation Entry"; CalcReservEntry2: Record "Reservation Entry"; Positive: Boolean; var sender: Codeunit "Reservation Management")    begin        if MatchThisEntry(ReservSummEntryNo) then            AutoReserveSalesLine(                CalcReservEntry, sender, ReservSummEntryNo, RemainingQtyToReserve, RemainingQtyToReserveBase,                Description, AvailabilityDate, Search, NextStep, Positive);    end;    local procedure AutoReserveSalesLine(var CalcReservEntry: Record "Reservation Entry"; var sender: Codeunit "Reservation Management"; ReservSummEntryNo: Integer; var RemainingQtyToReserve: Decimal; var RemainingQtyToReserveBase: Decimal; Description: Text[100]; AvailabilityDate: Date; Search: Text[1]; NextStep: Integer; Positive: Boolean)    var        CallTrackingSpecification: Record "Tracking Specification";        SalesLine: Record "Sales Line";        QtyThisLine: Decimal;        QtyThisLineBase: Decimal;        ReservQty: Decimal;        IsReserved: Boolean;    begin        IsReserved := false;        OnBeforeAutoReserveSalesLine(          ReservSummEntryNo, RemainingQtyToReserve, RemainingQtyToReserveBase, Description, AvailabilityDate, IsReserved, Search, NextStep, CalcReservEntry);        if IsReserved then            exit;        SalesLine.SetAutoCalcFields("Reserved Qty. (Base)");        SalesLine.FilterLinesForReservation(          CalcReservEntry, Enum::"Sales Document Type".FromInteger(ReservSummEntryNo - Enum::"Reservation Summary Type"::"Sales Quote".AsInteger()),          sender.GetAvailabilityFilter(AvailabilityDate), Positive);        if SalesLine.Find(Search) then            repeat                QtyThisLine := SalesLine."Outstanding Quantity";                QtyThisLineBase := SalesLine."Outstanding Qty. (Base)";                if ReservSummEntryNo = Enum::"Reservation Summary Type"::"Sales Return Order".AsInteger() then // Return Order                    ReservQty := -SalesLine."Reserved Qty. (Base)"                else                    ReservQty := SalesLine."Reserved Qty. (Base)";                if (Positive = (QtyThisLineBase > 0)) and (ReservSummEntryNo <> Enum::"Reservation Summary Type"::"Sales Return Order".AsInteger()) or                   (Positive = (QtyThisLineBase < 0)) and (ReservSummEntryNo = Enum::"Reservation Summary Type"::"Sales Return Order".AsInteger())                then begin                    QtyThisLine := 0;                    QtyThisLineBase := 0;                end;                sender.SetQtyToReserveDownToTrackedQuantity(CalcReservEntry, SalesLine.RowID1(), QtyThisLine, QtyThisLineBase);                CallTrackingSpecification.InitTrackingSpecification(                  Database::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", '', 0, SalesLine."Line No.",                  SalesLine."Variant Code", SalesLine."Location Code", SalesLine."Qty. per Unit of Measure");                CallTrackingSpecification.CopyTrackingFromReservEntry(CalcReservEntry);                sender.InsertReservationEntries(                    RemainingQtyToReserve, RemainingQtyToReserveBase, ReservQty,                    Description, SalesLine."Shipment Date", QtyThisLine, QtyThisLineBase, CallTrackingSpecification);            until (SalesLine.Next(NextStep) = 0) or (RemainingQtyToReserveBase = 0);    end;    local procedure CheckQuantityReducedOnSalesLine(NewSalesLine: Record "Sales Line"; OldSalesLine: Record "Sales Line"): Boolean    var        Item: Record Item;    begin        if (NewSalesLine.Type <> NewSalesLine.Type::Item) or (NewSalesLine.Quantity = 0) or (NewSalesLine.Reserve <> NewSalesLine.Reserve::Always) then            exit(false);        if ShipmentExists(NewSalesLine) then            exit(false);        Item.SetLoadFields("Costing Method");        Item.Get(NewSalesLine."No.");        if Item."Costing Method" <> Item."Costing Method"::FIFO then            exit(false);        exit(NewSalesLine.Quantity < OldSalesLine.Quantity);    end;    local procedure ShipmentExists(SalesLine: Record "Sales Line"): Boolean    var        SalesShipmentLine: Record "Sales Shipment Line";    begin        SalesShipmentLine.SetRange("Document No.", SalesLine."Shipment No.");        SalesShipmentLine.SetRange("Line No.", SalesLine."Shipment Line No.");        exit(not SalesShipmentLine.IsEmpty());    end;    /// <summary>    /// Raised after calculating the quantity to reserve for a sales line.    /// </summary>    /// <param name="SalesLine">The sales line for which the quantity was calculated.</param>    /// <param name="QtyToReserve">The quantity to reserve in the sales unit of measure.</param>    /// <param name="QtyToReserveBase">The quantity to reserve in base unit of measure.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterReservQuantity(SalesLine: Record "Sales Line"; var QtyToReserve: Decimal; var QtyToReserveBase: Decimal)    begin    end;    /// <summary>    /// Raised before assigning a sales line for planning purposes.    /// </summary>    /// <param name="SalesLine">The sales line to assign for planning.</param>    /// <param name="IsHandled">Set to true to skip the default assignment logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeAssignForPlanning(var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before deleting sales reservation entries when a sales line is modified.    /// </summary>    /// <param name="NewSalesLine">The modified sales line.</param>    /// <param name="OldSalesLine">The original sales line before modification.</param>    /// <param name="ReservMgt">The reservation management codeunit instance.</param>    /// <param name="IsHandled">Set to true to skip the default deletion logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteSalesReservEntries(var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; var ReservMgt: Codeunit "Reservation Management"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before retrieving the invoice specification for item tracking on a sales line.    /// </summary>    /// <param name="SalesLine">The sales line for which to retrieve the specification.</param>    /// <param name="OK">Set to the result of the retrieval operation.</param>    /// <param name="IsHandled">Set to true to skip the default retrieval logic.</param>    /// <param name="TempInvoicingSpecification">The temporary tracking specification record for invoicing.</param>    [IntegrationEvent(true, false)]    local procedure OnBeforeRetrieveInvoiceSpecification(var SalesLine: Record "Sales Line"; var OK: Boolean; var IsHandled: Boolean; var TempInvoicingSpecification: Record "Tracking Specification" temporary)    begin    end;    /// <summary>    /// Raised before retrieving the invoice specification (variant 2) for item tracking on a sales line.    /// </summary>    /// <param name="SalesLine">The sales line for which to retrieve the specification.</param>    /// <param name="OK">Set to the result of the retrieval operation.</param>    /// <param name="IsHandled">Set to true to skip the default retrieval logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeRetrieveInvoiceSpecification2(var SalesLine: Record "Sales Line"; var OK: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before transferring reservation entries from one sales line to another.    /// </summary>    /// <param name="OldSalesLine">The source sales line from which to transfer.</param>    /// <param name="NewSalesLine">The destination sales line to which to transfer.</param>    /// <param name="TransferQty">The quantity to transfer.</param>    /// <param name="IsHandled">Set to true to skip the default transfer logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTransferSaleLineToSalesLine(var OldSalesLine: Record "Sales Line"; var NewSalesLine: Record "Sales Line"; var TransferQty: Decimal; var IsHandled: Boolean);    begin    end;    /// <summary>    /// Raised before verifying changes to a sales line that may affect reservations.    /// </summary>    /// <param name="NewSalesLine">The modified sales line.</param>    /// <param name="OldSalesLine">The original sales line before modification.</param>    /// <param name="IsHandled">Set to true to skip the default verification logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeVerifyChange(var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before testing the variant code during reservation creation.    /// </summary>    /// <param name="SalesLine">The sales line for which the reservation is being created.</param>    /// <param name="FromTrackingSpecification">The tracking specification containing variant information.</param>    /// <param name="IsHandled">Set to true to skip the default variant code test.</param>    [IntegrationEvent(false, false)]    local procedure OnCreateReservationOnBeforeTestVariantCode(SalesLine: Record "Sales Line"; FromTrackingSpecification: Record "Tracking Specification"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before testing the location code during reservation creation.    /// </summary>    /// <param name="SalesLine">The sales line for which the reservation is being created.</param>    /// <param name="FromTrackingSpecification">The tracking specification containing location information.</param>    /// <param name="IsHandled">Set to true to skip the default location code test.</param>    [IntegrationEvent(false, false)]    local procedure OnCreateReservationOnBeforeTestLocationCode(SalesLine: Record "Sales Line"; FromTrackingSpecification: Record "Tracking Specification"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before testing the bin code when verifying sales line modifications.    /// </summary>    /// <param name="NewSalesLine">The modified sales line.</param>    /// <param name="OldSalesLine">The original sales line before modification.</param>    /// <param name="IsHandled">Set to true to skip the default bin code test.</param>    [IntegrationEvent(false, false)]    local procedure OnTestSalesLineModificationOnBeforeTestBinCode(var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before testing the job number when verifying sales line modifications.    /// </summary>    /// <param name="SalesLine">The sales line being tested.</param>    /// <param name="IsHandled">Set to true to skip the default job number test.</param>    [IntegrationEvent(false, false)]    local procedure OnTestSalesLineModificationOnBeforeTestJobNo(SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before testing the variant code when verifying sales line modifications.    /// </summary>    /// <param name="NewSalesLine">The modified sales line.</param>    /// <param name="OldSalesLine">The original sales line before modification.</param>    /// <param name="IsHandled">Set to true to skip the default variant code test.</param>    /// <param name="HasError">Set to true if an error condition was detected.</param>    /// <param name="ThrowError">Indicates whether errors should be thrown.</param>    [IntegrationEvent(false, false)]    local procedure OnTestSalesLineModificationOnBeforeTestVariantCode(var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; var IsHandled: Boolean; var HasError: Boolean; ThrowError: Boolean)    begin    end;    /// <summary>    /// Raised before testing the location code when verifying sales line modifications.    /// </summary>    /// <param name="NewSalesLine">The modified sales line.</param>    /// <param name="OldSalesLine">The original sales line before modification.</param>    /// <param name="IsHandled">Set to true to skip the default location code test.</param>    /// <param name="HasError">Set to true if an error condition was detected.</param>    [IntegrationEvent(false, false)]    local procedure OnTestSalesLineModificationOnBeforeTestLocationCode(var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; var IsHandled: Boolean; var HasError: Boolean)    begin    end;    /// <summary>    /// Raised before testing the item journal line during transfer from sales line.    /// </summary>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="IsHandled">Set to true to skip the default test.</param>    /// <param name="ItemJnlLine">The destination item journal line.</param>    /// <param name="TransferQty">The quantity being transferred.</param>    [IntegrationEvent(false, false)]    local procedure OnTransferSalesLineToItemJnlLineOnBeforeItemJournalLineTest(SalesLine: Record "Sales Line"; var IsHandled: Boolean; var ItemJnlLine: Record "Item Journal Line"; var TransferQty: Decimal);    begin    end;    /// <summary>    /// Raised before initializing the record set during transfer of sales line to item journal line.    /// </summary>    /// <param name="OldReservationEntry">The reservation entry being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnTransferSalesLineToItemJnlLineOnBeforeInitRecordSet(var OldReservationEntry: Record "Reservation Entry")    begin    end;    /// <summary>    /// Raised before testing the old reservation entry during transfer from sales line to item journal line.    /// </summary>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="IsHandled">Set to true to skip the default test.</param>    /// <param name="ItemJnlLine">The destination item journal line.</param>    [IntegrationEvent(false, false)]    local procedure OnTransferSalesLineToItemJnlLineOnBeforeOldReservEntryTest(SalesLine: Record "Sales Line"; var IsHandled: Boolean; var ItemJnlLine: Record "Item Journal Line");    begin    end;    /// <summary>    /// Raised before transferring the reservation entry from sales line to item journal line.    /// </summary>    /// <param name="ReservationEntry">The reservation entry being transferred.</param>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="ItemJournalLine">The destination item journal line.</param>    /// <param name="IsHandled">Set to true to skip the default transfer logic.</param>    [IntegrationEvent(false, false)]    local procedure OnTransferSalesLineToItemJnlLineOnBeforeTransferReservationEntry(var ReservationEntry: Record "Reservation Entry"; SalesLine: Record "Sales Line"; ItemJournalLine: Record "Item Journal Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before calculating the transfer quantity when transferring between sales lines.    /// </summary>    /// <param name="NewSalesLine">The destination sales line.</param>    /// <param name="OldReservationEntry">The source reservation entry.</param>    /// <param name="IsHandled">Set to true to skip the default calculation.</param>    [IntegrationEvent(false, false)]    local procedure OnTransferSaleLineToSalesLineOnBeforeCalcTransferQty(var NewSalesLine: Record "Sales Line"; var OldReservationEntry: Record "Reservation Entry"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before determining if an error occurred when verifying changes to a sales line.    /// </summary>    /// <param name="NewSalesLine">The modified sales line.</param>    /// <param name="OldSalesLine">The original sales line before modification.</param>    /// <param name="HasError">Set to true if an error condition was detected.</param>    /// <param name="ShowError">Set to true if the error should be displayed to the user.</param>    [IntegrationEvent(false, false)]    local procedure OnVerifyChangeOnBeforeHasError(NewSalesLine: Record "Sales Line"; OldSalesLine: Record "Sales Line"; var HasError: Boolean; var ShowError: Boolean)    begin    end;    /// <summary>    /// Raised before testing the Appl.-from Item Entry field during transfer from sales line to item journal line.    /// </summary>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="OldReservEntry">The source reservation entry.</param>    /// <param name="IsHandled">Set to true to skip the default test.</param>    /// <param name="ItemJnlLine">The destination item journal line.</param>    [IntegrationEvent(false, false)]    local procedure OnTransferSalesLineToItemJnlLineOnBeforeApplFromItemEntryTestField(SalesLine: Record "Sales Line"; OldReservEntry: Record "Reservation Entry"; var IsHandled: Boolean; var ItemJnlLine: Record "Item Journal Line")    begin    end;    /// <summary>    /// Raised before calling the item tracking page for a sales line.    /// </summary>    /// <param name="SalesLine">The sales line for which to open item tracking.</param>    /// <param name="IsHandled">Set to true to skip the default item tracking call.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCallItemTracking(var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before creating a reservation for a sales line.    /// </summary>    /// <param name="SalesLine">The sales line for which to create the reservation.</param>    /// <param name="IsHandled">Set to true to skip the default reservation creation.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateReservation(var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before deleting invoice specifications from a sales header.    /// </summary>    /// <param name="SalesHeader">The sales header from which to delete specifications.</param>    /// <param name="IsHandled">Set to true to skip the default deletion logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteInvoiceSpecFromHeader(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before deleting invoice specifications from a sales line.    /// </summary>    /// <param name="SalesLine">The sales line from which to delete specifications.</param>    /// <param name="IsHandled">Set to true to skip the default deletion logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteInvoiceSpecFromLine(var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before verifying quantity changes on a sales line that may affect reservations.    /// </summary>    /// <param name="NewSalesLine">The modified sales line.</param>    /// <param name="IsHandled">Set to true to skip the default quantity verification.</param>    /// <param name="OldSalesLine">The original sales line before modification.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeVerifyQuantity(var NewSalesLine: Record "Sales Line"; var IsHandled: Boolean; var OldSalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised before transferring a sales line to an item journal line.    /// </summary>    /// <param name="SalesLine">The source sales line.</param>    /// <param name="IsHandled">Set to true to skip the default transfer logic.</param>    /// <param name="ItemJnlLine">The destination item journal line.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTransferSalesLineToItemJnlLine(var SalesLine: Record "Sales Line"; var IsHandled: Boolean; var ItemJnlLine: Record "Item Journal Line")    begin    end;    /// <summary>    /// Raised before running the Item Tracking Lines page modally for a sales line.    /// </summary>    /// <param name="SalesLine">The sales line for which item tracking is being opened.</param>    /// <param name="ItemTrackingLines">The Item Tracking Lines page instance.</param>    [IntegrationEvent(false, false)]    local procedure OnCallItemTrackingOnBeforeItemTrackingLinesRunModal(var SalesLine: Record "Sales Line"; var ItemTrackingLines: Page "Item Tracking Lines")    begin    end;    /// <summary>    /// Raised before running the Item Tracking Lines page for a secondary source on a sales line.    /// </summary>    /// <param name="SalesLine">The sales line for which item tracking is being opened.</param>    /// <param name="ItemTrackingLines">The Item Tracking Lines page instance.</param>    [IntegrationEvent(false, false)]    local procedure OnCallItemTrackingSecondSourceOnBeforeItemTrackingLinesRun(var SalesLine: Record "Sales Line"; var ItemTrackingLines: Page "Item Tracking Lines")    begin    end;    /// <summary>    /// Raised before opening item tracking lines for a secondary source on a sales line.    /// </summary>    /// <param name="SalesLine">The sales line for which item tracking is being opened.</param>    /// <param name="TrackingSpecification">The tracking specification for the item.</param>    /// <param name="SecondSourceQuantityArray">Array containing secondary source quantities.</param>    /// <param name="IsHandled">Set to true to skip the default item tracking opening.</param>    [IntegrationEvent(false, false)]    local procedure OnCallItemTrackingSecondSourceOnBeforeOpenItemTrackingLines(var SalesLine: Record "Sales Line"; TrackingSpecification: Record "Tracking Specification"; SecondSourceQuantityArray: array[3] of Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before inserting a tracking specification when retrieving invoice specifications.    /// </summary>    /// <param name="TempInvoicingSpecification">The temporary invoicing specification to insert.</param>    /// <param name="ReservEntry">The source reservation entry.</param>    [IntegrationEvent(false, false)]    local procedure OnRetrieveInvoiceSpecificationOnBeforeInsert(var TempInvoicingSpecification: Record "Tracking Specification" temporary; ReservEntry: Record "Reservation Entry")    begin    end;    /// <summary>    /// Raised before checking the reserved quantity during reservation creation.    /// </summary>    /// <param name="SalesLine">The sales line for which the reservation is being created.</param>    /// <param name="IsHandled">Set to true to skip the default reserved quantity check.</param>    /// <param name="QuantityBase">The base quantity to check against.</param>    [IntegrationEvent(false, false)]    local procedure OnCreateReservationOnBeforeCheckReservedQty(var SalesLine: Record "Sales Line"; var IsHandled: Boolean; QuantityBase: Decimal)    begin    end;    /// <summary>    /// Raised before creating a reservation entry during reservation creation.    /// </summary>    /// <param name="SalesLine">The sales line for which the reservation is being created.</param>    /// <param name="Quantity">The quantity to reserve.</param>    /// <param name="QuantityBase">The base quantity to reserve.</param>    /// <param name="ForReservEntry">The reservation entry template.</param>    /// <param name="IsHandled">Set to true to skip the default reservation entry creation.</param>    /// <param name="FromTrackingSpecification">The source tracking specification.</param>    /// <param name="ExpectedReceiptDate">The expected receipt date for the reservation.</param>    /// <param name="Description">The description for the reservation entry.</param>    /// <param name="ShipmentDate">The shipment date for the reservation.</param>    /// <param name="DoCreateReservationEntry">Set to false to prevent the reservation entry from being created.</param>    [IntegrationEvent(false, false)]    local procedure OnCreateReservationOnBeforeCreateReservEntry(var SalesLine: Record "Sales Line"; var Quantity: Decimal; var QuantityBase: Decimal; var ForReservEntry: Record "Reservation Entry"; var IsHandled: Boolean; var FromTrackingSpecification: Record "Tracking Specification"; ExpectedReceiptDate: Date; Description: Text[100]; ShipmentDate: Date; var DoCreateReservationEntry: Boolean)    begin    end;    /// <summary>    /// Raised after creating a reservation for a sales line.    /// </summary>    /// <param name="SalesLine">The sales line for which the reservation was created.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCreateReservation(var SalesLine: Record "Sales Line")    begin    end;    /// <summary>    /// Raised before deleting reservation entries for a sales line.    /// </summary>    /// <param name="SalesLine">The sales line being deleted.</param>    /// <param name="IsHandled">Set to true to skip the default deletion logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteLine(var SalesLine: Record "Sales Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before automatically reserving a sales line.    /// </summary>    /// <param name="ReservSummEntryNo">The reservation summary entry number.</param>    /// <param name="RemainingQtyToReserve">The remaining quantity to reserve.</param>    /// <param name="RemainingQtyToReserveBase">The remaining base quantity to reserve.</param>    /// <param name="Description">The description for the reservation.</param>    /// <param name="AvailabilityDate">The availability date for the reservation.</param>    /// <param name="IsReserved">Set to true if the reservation was handled.</param>    /// <param name="Search">The search direction for finding entries.</param>    /// <param name="NextStep">The next step value for iterating through entries.</param>    /// <param name="CalcReservEntry">The reservation entry used for calculation.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeAutoReserveSalesLine(ReservSummEntryNo: Integer; var RemainingQtyToReserve: Decimal; var RemainingQtyToReserveBase: Decimal; Description: Text[100]; AvailabilityDate: Date; var IsReserved: Boolean; Search: Text[1]; NextStep: Integer; CalcReservEntry: Record "Reservation Entry")    begin    end;    /// <summary>    /// Raised before creating a reservation from the reservation management event handler.    /// </summary>    /// <param name="SalesLine">The sales line for which the reservation is being created.</param>    /// <param name="TrackingSpecification">The tracking specification for the reservation.</param>    /// <param name="Description">The description for the reservation.</param>    /// <param name="ExpectedDate">The expected date for the reservation.</param>    /// <param name="Quantity">The quantity to reserve.</param>    /// <param name="QuantityBase">The base quantity to reserve.</param>    /// <param name="ReservationEntry">The reservation entry template.</param>    [IntegrationEvent(false, false)]    local procedure OnCreateReservationOnBeforeCreateReservation(var SalesLine: Record "Sales Line"; var TrackingSpecification: Record "Tracking Specification"; var Description: Text[100]; var ExpectedDate: Date; var Quantity: Decimal; var QuantityBase: Decimal; var ReservationEntry: Record "Reservation Entry")    begin    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnAutoTrackOnCheckSourceType', '', false, false)]    local procedure OnAutoTrackOnCheckSourceType(var ReservationEntry: Record "Reservation Entry"; var ShouldExit: Boolean)    begin        if ReservationEntry."Source Type" = Database::"Sales Line" then            if not (ReservationEntry."Source Subtype" in [1, 5]) then                ShouldExit := true; // Only order, return order    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnTestItemType', '', false, false)]    local procedure OnTestItemType(SourceRecRef: RecordRef)    var        SalesLine: Record "Sales Line";    begin        if SourceRecRef.Number = Database::"Sales Line" then begin            SourceRecRef.SetTable(SalesLine);            SalesLine.TestField(Type, SalesLine.Type::Item);        end;    end;#if not CLEAN27    [Obsolete('This event is never raised.', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnSetSourceForReservationOnBeforeUpdateReservation(var ReservEntry: Record "Reservation Entry"; SalesLine: Record "Sales Line")    begin    end;    [Obsolete('This event is never raised.', '27.0')]    [IntegrationEvent(false, false)]    local procedure OnAfterSetSourceForReservation(var CalcReservEntry: Record "Reservation Entry"; SalesLine: Record "Sales Line")    begin    end;#endif    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Management", 'OnAutoReserveOnBeforeStopReservation', '', false, false)]    local procedure OnAutoReserveOnBeforeStopReservation(var CalcReservEntry: Record "Reservation Entry"; var StopReservation: Boolean; SourceRecRef: RecordRef);    var        SalesLine: Record "Sales Line";    begin        if MatchThisTable(CalcReservEntry."Source Type") then begin            StopReservation := not (CalcReservEntry."Source Subtype" in [1, 5]);  // Only order and return order            SourceRecRef.SetTable(SalesLine);            if (CalcReservEntry."Source Subtype" = 1) and (SalesLine.Quantity < 0) then                StopReservation := true;            if (CalcReservEntry."Source Subtype" = 5) and (SalesLine.Quantity >= 0) then                StopReservation := true;        end;    end;    // codeunit Create Reserv. entry subscribers    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Create Reserv. Entry", 'OnCheckSourceTypeSubtype', '', false, false)]    local procedure CheckSourceTypeSubtype(var ReservationEntry: Record "Reservation Entry"; var IsError: Boolean)    var        IsHandled: Boolean;    begin        if MatchThisTable(ReservationEntry."Source Type") then begin            OnBeforeCheckSourceTypeSubtypeOnBeforeIsError(ReservationEntry, IsError, IsHandled);            if IsHandled then                exit;            IsError := not (ReservationEntry."Source Subtype" in [1, 5]);        end;    end;    // codeunit Reservation Engine Mgt. subscribers    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Engine Mgt.", 'OnRevertDateToSourceDate', '', false, false)]    local procedure OnRevertDateToSourceDate(var ReservEntry: Record "Reservation Entry")    var        SalesLine: Record "Sales Line";    begin        if ReservEntry."Source Type" = Database::"Sales Line" then begin            SalesLine.Get(ReservEntry."Source Subtype", ReservEntry."Source ID", ReservEntry."Source Ref. No.");            if ReservEntry.Positive then                ReservEntry."Shipment Date" := 0D            else begin                ReservEntry."Expected Receipt Date" := 0D;                ReservEntry."Shipment Date" := SalesLine."Shipment Date";            end;        end;    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Engine Mgt.", 'OnGetActivePointerFieldsOnBeforeAssignArrayValues', '', false, false)]    local procedure OnGetActivePointerFieldsOnBeforeAssignArrayValues(TableID: Integer; var PointerFieldIsActive: array[6] of Boolean; var IsHandled: Boolean)    begin        if TableID = Database::"Sales Line" then begin            PointerFieldIsActive[1] := true;  // Type            PointerFieldIsActive[2] := true;  // SubType            PointerFieldIsActive[3] := true;  // ID            PointerFieldIsActive[6] := true;  // RefNo        end;    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Reservation Engine Mgt.", 'OnCreateText', '', false, false)]    local procedure OnAfterCreateText(ReservationEntry: Record "Reservation Entry"; var Description: Text[80])    begin        if ReservationEntry."Source Type" = Database::"Sales Line" then            Description :=                StrSubstNo(SourceDoc3Txt, SalesTxt,                Enum::"Sales Document Type".FromInteger(ReservationEntry."Source Subtype"), ReservationEntry."Source ID");    end;    /// <summary>    /// Initializes a tracking specification from a sales line for item tracking purposes.    /// </summary>    /// <param name="TransactionSpecification">Returns the initialized tracking specification.</param>    /// <param name="SalesLine">The sales line to initialize from.</param>    procedure InitFromSalesLine(var TransactionSpecification: Record "Tracking Specification"; SalesLine: Record "Sales Line")    begin        TransactionSpecification.Init();        TransactionSpecification.SetItemData(          SalesLine."No.", SalesLine.Description, SalesLine."Location Code", SalesLine."Variant Code", SalesLine."Bin Code",          SalesLine."Qty. per Unit of Measure", SalesLine."Qty. Rounding Precision (Base)");        TransactionSpecification.SetSource(          Database::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.", '', 0);        if SalesLine.IsCreditDocType() then            TransactionSpecification.SetQuantities(              SalesLine."Quantity (Base)", SalesLine."Return Qty. to Receive", SalesLine."Return Qty. to Receive (Base)",              SalesLine."Qty. to Invoice", SalesLine."Qty. to Invoice (Base)", SalesLine."Return Qty. Received (Base)",              SalesLine."Qty. Invoiced (Base)")        else            TransactionSpecification.SetQuantities(              SalesLine."Quantity (Base)", SalesLine."Qty. to Ship", SalesLine."Qty. to Ship (Base)", SalesLine."Qty. to Invoice",              SalesLine."Qty. to Invoice (Base)", SalesLine."Qty. Shipped (Base)", SalesLine."Qty. Invoiced (Base)");        OnAfterInitFromSalesLine(TransactionSpecification, SalesLine);    end;    /// <summary>    /// Raised after initializing a tracking specification from a sales line.    /// </summary>    /// <param name="TrackingSpecification">The tracking specification that was initialized.</param>    /// <param name="SalesLine">The source sales line.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInitFromSalesLine(var TrackingSpecification: Record "Tracking Specification"; SalesLine: Record "Sales Line")    begin    end;    [EventSubscriber(ObjectType::Table, Database::"Tracking Specification", 'OnBeforeCheckApplyFromItemEntrySourceType', '', false, false)]    local procedure OnBeforeCheckApplyFromItemEntrySourceType(var TrackingSpecification: Record "Tracking Specification"; var IsHandled: Boolean)    begin        if not MatchThisTable(TrackingSpecification."Source Type") then            exit;        if ((TrackingSpecification."Source Subtype" in [3, 5]) and (TrackingSpecification."Quantity (Base)" < 0)) or            ((TrackingSpecification."Source Subtype" in [1, 2]) and (TrackingSpecification."Quantity (Base)" > 0)) // sale        then            TrackingSpecification.FieldError("Quantity (Base)");        IsHandled := true;    end;    [EventSubscriber(ObjectType::Table, Database::"Reservation Entry", 'OnAfterSummEntryNo', '', false, false)]    local procedure OnBeforeSummEntryNo(ReservationEntry: Record "Reservation Entry"; var ReturnValue: Integer)    begin        if MatchThisTable(ReservationEntry."Source Type") then            ReturnValue := Enum::"Reservation Summary Type"::"Sales Quote".AsInteger() + ReservationEntry."Source Subtype";    end;    [EventSubscriber(ObjectType::Table, Database::"Reservation Entry", 'OnUpdateSourceCost', '', false, false)]    local procedure ReservationEntryOnUpdateSourceCost(ReservationEntry: Record "Reservation Entry"; UnitCost: Decimal)    var        SalesLine: Record "Sales Line";        QtyToReserveNonBase: Decimal;        QtyToReserve: Decimal;        QtyReservedNonBase: Decimal;        QtyReserved: Decimal;    begin        if MatchThisTable(ReservationEntry."Source Type") then begin            SalesLine.Get(ReservationEntry."Source Subtype", ReservationEntry."Source ID", ReservationEntry."Source Ref. No.");            SalesLine.GetReservationQty(QtyReservedNonBase, QtyReserved, QtyToReserveNonBase, QtyToReserve);            if SalesLine."Qty. per Unit of Measure" <> 0 then                SalesLine."Unit Cost (LCY)" :=                    Round(SalesLine."Unit Cost (LCY)" / SalesLine."Qty. per Unit of Measure");            if SalesLine."Quantity (Base)" <> 0 then                SalesLine."Unit Cost (LCY)" :=                    Round(                    (SalesLine."Unit Cost (LCY)" *                        (SalesLine."Quantity (Base)" - QtyReserved) +                        UnitCost * QtyReserved) / SalesLine."Quantity (Base)", 0.00001);            if SalesLine."Qty. per Unit of Measure" <> 0 then                SalesLine."Unit Cost (LCY)" :=                    Round(SalesLine."Unit Cost (LCY)" * SalesLine."Qty. per Unit of Measure");            SalesLine.Validate("Unit Cost (LCY)");            SalesLine.Modify();        end;    end;    [EventSubscriber(ObjectType::Table, Database::"Requisition Line", 'OnReserveBindingOrder', '', false, false)]    local procedure OnReserveBindingOrder(var RequisitionLine: Record "Requisition Line"; TrackingSpecification: Record "Tracking Specification"; SourceDescription: Text[100]; ExpectedDate: Date; ReservQty: Decimal; ReservQtyBase: Decimal; UpdateReserve: Boolean)    begin        if RequisitionLine."Demand Type" = Database::"Sales Line" then            SalesLineBindToTracking(RequisitionLine, TrackingSpecification, SourceDescription, ExpectedDate, ReservQty, ReservQtyBase, UpdateReserve);    end;    local procedure SalesLineBindToTracking(RequisitionLine: Record "Requisition Line"; TrackingSpecification: Record "Tracking Specification"; Description: Text[100]; ExpectedDate: Date; ReservQty: Decimal; ReservQtyBase: Decimal; UpdateReserve: Boolean)    var        SalesLine: Record "Sales Line";    begin        SalesLine.Get(RequisitionLine."Demand Subtype", RequisitionLine."Demand Order No.", RequisitionLine."Demand Line No.");        if TrackingSpecification."Source Type" <> Database::"Requisition Line" then begin            BindToTracking(SalesLine, TrackingSpecification, Description, ExpectedDate, ReservQty, ReservQtyBase);            if UpdateReserve then                SalesLine.SetReserveToOptional();        end else begin            if not SalesLine."Drop Shipment" then                SalesLine.SetReserveToOptional();            if SalesLine.Reserve <> SalesLine.Reserve::Never then                BindToTracking(SalesLine, TrackingSpecification, Description, ExpectedDate, ReservQty, ReservQtyBase);        end;    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::OrderTrackingManagement, 'OnSetSourceRecord', '', false, false)]    local procedure OrderTrackingManagementOnSetSourceRecord(var SourceRecordVar: Variant; var ReservationEntry: Record "Reservation Entry"; var ItemLedgerEntry2: Record "Item Ledger Entry")    var        SalesLine: Record "Sales Line";        SourceRecRef: RecordRef;    begin        SourceRecRef.GetTable(SourceRecordVar);        if MatchThisTable(SourceRecRef.Number) then begin            SalesLine := SourceRecordVar;            SetSalesLine(SalesLine, ReservationEntry, ItemLedgerEntry2);        end;    end;    local procedure SetSalesLine(var SalesLine: Record "Sales Line"; var ReservEntry: Record "Reservation Entry"; var ItemLedgerEntry: Record "Item Ledger Entry")    var        SaleShptLine: Record "Sales Shipment Line";    begin        SalesLine.TestField(Type, SalesLine.Type::Item);        ReservEntry."Source Type" := DATABASE::"Sales Line";        ReservEntry.InitSortingAndFilters(false);        SalesLine.SetReservationFilters(ReservEntry);        if SalesLine."Qty. Shipped (Base)" <> 0 then begin            SaleShptLine.SetCurrentKey("Order No.", "Order Line No.");            SaleShptLine.SetRange("Order No.", SalesLine."Document No.");            SaleShptLine.SetRange("Order Line No.", SalesLine."Line No.");            if SaleShptLine.Find('-') then                repeat                    if ItemLedgerEntry.Get(SaleShptLine."Item Shpt. Entry No.") then                        ItemLedgerEntry.Mark(true);                until SaleShptLine.Next() = 0;        end;    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::OrderTrackingManagement, 'OnInsertOrderTrackingEntry', '', false, false)]    local procedure OnInsertOrderTrackingEntry(var OrderTrackingEntry: Record "Order Tracking Entry")    var        SalesLine: Record "Sales Line";    begin        if OrderTrackingEntry."For Type" = DATABASE::"Sales Line" then            if SalesLine.Get(OrderTrackingEntry."For Subtype", OrderTrackingEntry."For ID", OrderTrackingEntry."For Ref. No.") then begin                OrderTrackingEntry."Starting Date" := SalesLine."Shipment Date";                OrderTrackingEntry."Ending Date" := SalesLine."Shipment Date";            end;    end;    /// <summary>    /// Raised before checking the source type and subtype for error conditions in reservation entries.    /// </summary>    /// <param name="ReservationEntry">The reservation entry being checked.</param>    /// <param name="IsError">Set to true if an error condition was detected.</param>    /// <param name="IsHandled">Set to true to skip the default check logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckSourceTypeSubtypeOnBeforeIsError(var ReservationEntry: Record "Reservation Entry"; var IsError: Boolean; var IsHandled: Boolean)    begin    end;    [EventSubscriber(ObjectType::Table, Database::"Tracking Specification", 'OnGetSourceShipmentDate', '', false, false)]    local procedure OnGetSourceShipmentDate(var TrackingSpecification: Record "Tracking Specification"; var ShipmentDate: Date);    var        SalesLine: Record "Sales Line";    begin        if TrackingSpecification."Source Type" = Database::"Sales Line" then begin            SalesLine.Get(TrackingSpecification."Source Subtype", TrackingSpecification."Source ID", TrackingSpecification."Source Ref. No.");            ShipmentDate := SalesLine."Shipment Date";        end;    end;}