Codeunit 392 Reminder-Make

Base Application, Microsoft.Sales.Reminder

src/Layers/W1/BaseApp/Sales/Reminder/ReminderMake.Codeunit.al1,244 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.Reminder;using Microsoft.Finance.Currency;using Microsoft.Sales.Customer;using Microsoft.Sales.FinanceCharge;using Microsoft.Sales.Receivables;using System.Globalization;using System.Telemetry;using System.Utilities;/// <summary>/// Creates reminder documents for customers by analyzing overdue ledger entries and applying reminder terms./// </summary>codeunit 392 "Reminder-Make"{    trigger OnRun()    begin    end;    var        TempCurrencyGlobal: Record Currency temporary;        GlobalCustomer: Record Customer;        GlobalCustLedgEntry: Record "Cust. Ledger Entry";        GlobalCustLedgEntry2: Record "Cust. Ledger Entry";        GlobalReminderTerms: Record "Reminder Terms";        GlobalReminderHeaderReq: Record "Reminder Header";        GlobalReminderHeader: Record "Reminder Header";        GlobalReminderEntry: Record "Reminder/Fin. Charge Entry";        TempCustLedgerEntryOnHold: Record "Cust. Ledger Entry" temporary;        GlobalCustLedgEntryLineFeeFilters: Record "Cust. Ledger Entry";        FeatureTelemetry: Codeunit "Feature Telemetry";        AmountsNotDueLineInserted: Boolean;        OverdueEntriesOnly: Boolean;        HeaderExists: Boolean;        IncludeEntriesOnHold: Boolean;        OpenEntriesNotDueLbl: Label 'Open Entries Not Due';        OpenEntriesOnHoldLbl: Label 'Open Entries On Hold';        CustLedgEntryLastIssuedReminderLevelFilter: Text;    /// <summary>    /// Executes the reminder creation process for the configured customer and ledger entry filters.    /// </summary>    /// <returns>True if at least one reminder was created successfully; otherwise, false.</returns>    procedure "Code"() RetVal: Boolean    var        ReminderLine: Record "Reminder Line";        IsHandled: Boolean;    begin        CustLedgEntryLastIssuedReminderLevelFilter := GlobalCustLedgEntry.GetFilter("Last Issued Reminder Level");        if GlobalReminderHeader."No." <> '' then begin            HeaderExists := true;            GlobalReminderHeader.TestField("Customer No.");            GlobalCustomer.Get(GlobalReminderHeader."Customer No.");            IsHandled := false;            OnCodeOnAfterGlobalReminderGetGlobalCustomer(GlobalReminderHeader, GlobalCustomer, IsHandled, RetVal);            if IsHandled then                exit(RetVal);            GlobalReminderHeader.TestField("Document Date");            GlobalReminderHeader.TestField("Reminder Terms Code");            GlobalReminderHeaderReq := GlobalReminderHeader;            ReminderLine.SetRange("Reminder No.", GlobalReminderHeader."No.");            ReminderLine.DeleteAll();        end;        IsHandled := false;        OnCodeOnBeforeGetReminderTerms(GlobalCustomer, GlobalCustLedgEntry, CustLedgEntryLastIssuedReminderLevelFilter, GlobalReminderHeader, IsHandled, RetVal);        if IsHandled then            exit(RetVal);        GetReminderTerms();        if HeaderExists then            RetVal := MakeReminder(GlobalReminderHeader."Currency Code")        else begin            TempCurrencyGlobal.DeleteAll();            GlobalCustLedgEntry2.CopyFilters(GlobalCustLedgEntry);            GlobalCustLedgEntry.SetCurrentKey("Customer No.", Open, Positive);            GlobalCustLedgEntry.SetRange("Customer No.", GlobalCustomer."No.");            GlobalCustLedgEntry.SetRange(Open, true);            GlobalCustLedgEntry.SetRange(Positive, true);            OnBeforeCustLedgerEntryFind(GlobalCustLedgEntry, GlobalReminderHeaderReq, GlobalCustomer);            if GlobalCustLedgEntry.FindSet() then                repeat                    if (GlobalCustLedgEntry."On Hold" = '') or IncludeEntriesOnHold then begin                        TempCurrencyGlobal.Code := GlobalCustLedgEntry."Currency Code";                        if TempCurrencyGlobal.Insert() then;                    end;                until GlobalCustLedgEntry.Next() = 0;            GlobalCustLedgEntry.CopyFilters(GlobalCustLedgEntry2);            RetVal := true;            OnCodeOnBeforeCurrencyLoop(GlobalCustLedgEntry, GlobalReminderHeaderReq, GlobalReminderTerms, OverdueEntriesOnly,                IncludeEntriesOnHold, HeaderExists, CustLedgEntryLastIssuedReminderLevelFilter, TempCurrencyGlobal,                GlobalCustomer, GlobalCustLedgEntryLineFeeFilters);            if TempCurrencyGlobal.FindSet() then                repeat                    if not MakeReminder(TempCurrencyGlobal.Code) then                        RetVal := false;                until TempCurrencyGlobal.Next() = 0;        end;        OnAfterCode(RetVal);    end;    local procedure GetReminderTerms()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetReminderTerms(GlobalReminderHeader, GlobalReminderTerms, IsHandled);        if IsHandled then            exit;        if GlobalCustomer."Reminder Terms Code" = '' then            GlobalReminderHeader.TestField("Reminder Terms Code");        if GlobalReminderHeader."Reminder Terms Code" = '' then begin            GlobalCustomer.TestField("Reminder Terms Code");            GlobalReminderTerms.Get(GlobalCustomer."Reminder Terms Code");        end else            GlobalReminderTerms.Get(GlobalReminderHeader."Reminder Terms Code")    end;    /// <summary>    /// Initializes the reminder creation parameters for batch processing of customer reminders.    /// </summary>    /// <param name="Cust2">Specifies the customer to create reminders for.</param>    /// <param name="CustLedgEntry2">Specifies the customer ledger entries filter to include.</param>    /// <param name="ReminderHeaderReq2">Specifies the reminder header settings to use as a template.</param>    /// <param name="OverdueEntriesOnly2">Specifies whether to include only overdue entries.</param>    /// <param name="IncludeEntriesOnHold2">Specifies whether to include entries that are on hold.</param>    /// <param name="CustLedgEntryLinefeeOn">Specifies the customer ledger entries filter for line fee calculation.</param>    procedure Set(Cust2: Record Customer; var CustLedgEntry2: Record "Cust. Ledger Entry"; ReminderHeaderReq2: Record "Reminder Header"; OverdueEntriesOnly2: Boolean; IncludeEntriesOnHold2: Boolean; var CustLedgEntryLinefeeOn: Record "Cust. Ledger Entry")    begin        GlobalCustomer := Cust2;        GlobalCustLedgEntry.Copy(CustLedgEntry2);        GlobalReminderHeaderReq := ReminderHeaderReq2;        OverdueEntriesOnly := OverdueEntriesOnly2;        IncludeEntriesOnHold := IncludeEntriesOnHold2;        GlobalCustLedgEntryLineFeeFilters.CopyFilters(CustLedgEntryLinefeeOn);        OnAfterSet(GlobalCustomer, GlobalCustLedgEntry, GlobalReminderHeaderReq, OverdueEntriesOnly, IncludeEntriesOnHold, CustLedgEntryLinefeeOn);    end;    /// <summary>    /// Suggests reminder lines for an existing reminder header based on overdue customer ledger entries.    /// </summary>    /// <param name="ReminderHeader2">Specifies the reminder header to add suggested lines to.</param>    /// <param name="CustLedgEntry2">Specifies the customer ledger entries filter to include.</param>    /// <param name="OverdueEntriesOnly2">Specifies whether to include only overdue entries.</param>    /// <param name="IncludeEntriesOnHold2">Specifies whether to include entries that are on hold.</param>    /// <param name="CustLedgEntryLinefeeOn">Specifies the customer ledger entries filter for line fee calculation.</param>    procedure SuggestLines(ReminderHeader2: Record "Reminder Header"; var CustLedgEntry2: Record "Cust. Ledger Entry"; OverdueEntriesOnly2: Boolean; IncludeEntriesOnHold2: Boolean; var CustLedgEntryLinefeeOn: Record "Cust. Ledger Entry")    begin        GlobalReminderHeader := ReminderHeader2;        GlobalCustLedgEntry.Copy(CustLedgEntry2);        OverdueEntriesOnly := OverdueEntriesOnly2;        IncludeEntriesOnHold := IncludeEntriesOnHold2;        GlobalCustLedgEntryLineFeeFilters.CopyFilters(CustLedgEntryLinefeeOn);        OnAfterSuggestLines(GlobalReminderHeader, CustLedgEntry2, OverdueEntriesOnly2, IncludeEntriesOnHold2, CustLedgEntryLinefeeOn);    end;    local procedure MakeReminder(CurrencyCode: Code[10]) RetVal: Boolean    var        ReminderLevel: Record "Reminder Level";        ReminderLine: Record "Reminder Line";        MakeDoc: Boolean;        StartLineInserted: Boolean;        NextLineNo: Integer;        LineLevel: Integer;        MaxLineLevel: Integer;        MaxReminderLevel: Integer;        CustAmount: Decimal;        ReminderDueDate: Date;        OpenEntriesNotDueTranslated: Text[100];        OpenEntriesOnHoldTranslated: Text[100];        IsHandled: Boolean;        IsGracePeriodExpired: Boolean;        ShouldMakeDoc: Boolean;    begin        IsHandled := false;        OnBeforeMakeReminder(GlobalReminderHeader, CurrencyCode, RetVal, IsHandled, GlobalReminderHeaderReq, OverdueEntriesOnly, IncludeEntriesOnHold, HeaderExists, GlobalCustomer);        if IsHandled then            exit;        FilterCustLedgEntryReminderLevel(GlobalCustLedgEntry, ReminderLevel, CurrencyCode);        if not ReminderLevel.FindLast() then            exit(false);        TempCustLedgerEntryOnHold.DeleteAll();        if not FindAndMarkReminderCandidates(GlobalCustLedgEntry, ReminderLevel, CustAmount, MakeDoc, MaxReminderLevel, MaxLineLevel) then            exit(false);        ReminderLevel.SetRange("Reminder Terms Code", GlobalReminderTerms.Code);        ReminderLevel.SetRange("No.", 1, MaxLineLevel);        if not ReminderLevel.FindLast() then            ReminderLevel.Init();        ShouldMakeDoc := MakeDoc and (CustAmount > 0) and (CustAmountLCY(CurrencyCode, CustAmount) >= GlobalReminderTerms."Minimum Amount (LCY)");        OnMakeReminderOnAfterCalcShouldMakeDoc(GlobalReminderHeaderReq, GlobalReminderHeader, GlobalCustomer, ShouldMakeDoc, MakeDoc, GlobalCustLedgEntry);        if ShouldMakeDoc then begin            if CheckCustomerIsBlocked(GlobalCustomer) then                exit(false);            ReminderLine.LockTable();            GlobalReminderHeader.LockTable();            if not HeaderExists then begin                GlobalReminderHeader.SetCurrentKey("Customer No.", "Currency Code");                GlobalReminderHeader.SetRange("Customer No.", GlobalCustomer."No.");                GlobalReminderHeader.SetRange("Currency Code", CurrencyCode);                OnBeforeReminderHeaderFind(GlobalReminderHeader, GlobalReminderHeaderReq, GlobalReminderTerms, GlobalCustomer, GlobalCustLedgEntry);                if GlobalReminderHeader.FindFirst() then                    exit(false);                GlobalReminderHeader.Init();                GlobalReminderHeader."No." := '';                GlobalReminderHeader."Posting Date" := GlobalReminderHeaderReq."Posting Date";                OnBeforeReminderHeaderInsert(GlobalReminderHeader, GlobalReminderHeaderReq, GlobalReminderTerms, GlobalCustomer);                GlobalReminderHeader.Insert(true);                GlobalReminderHeader.Validate("Customer No.", GlobalCustomer."No.");                GlobalReminderHeader.Validate("Currency Code", CurrencyCode);                GlobalReminderHeader."Document Date" := GlobalReminderHeaderReq."Document Date";                GlobalReminderHeader."Use Header Level" := GlobalReminderHeaderReq."Use Header Level";            end;            GlobalReminderHeader."Reminder Level" := ReminderLevel."No.";            OnBeforeReminderHeaderModify(GlobalReminderHeader, GlobalReminderHeaderReq, HeaderExists, GlobalReminderTerms, GlobalCustomer, ReminderLevel, GlobalCustLedgEntry);            GlobalReminderHeader.Modify();            NextLineNo := 0;            ReminderLevel.MarkedOnly(true);            GlobalCustLedgEntry.MarkedOnly(true);            ReminderLevel.FindLast();            repeat                StartLineInserted := false;                FilterCustLedgEntries(ReminderLevel);                OnMakeReminderOnAfterFilterCustLedgEntries(ReminderLine);                AmountsNotDueLineInserted := false;                if GlobalCustLedgEntry.FindSet() then                    repeat                        SetReminderLine(LineLevel, ReminderDueDate);                        IsGracePeriodExpired := IsGracePeriodExpiredForOverdueEntry(ReminderDueDate, GlobalReminderHeaderReq."Document Date", ReminderLevel."Grace Period");                        OnMakeReminderOnAfterCalcIsGracePeriodExpired(ReminderDueDate, GlobalReminderHeaderReq, IsGracePeriodExpired);                        if IsGracePeriodExpired then begin                            if (NextLineNo > 0) and not StartLineInserted then                                InsertReminderLine(                                  GlobalReminderHeader."No.", ReminderLine."Line Type"::"Reminder Line", '', NextLineNo);                            InitReminderLine(                              ReminderLine, GlobalReminderHeader."No.", ReminderLine."Line Type"::"Reminder Line", '', NextLineNo);                            ReminderLine.Type := ReminderLine.Type::"Customer Ledger Entry";                            ReminderLine.Validate("Entry No.", GlobalCustLedgEntry."Entry No.");                            SetReminderLevel(GlobalReminderHeader, ReminderLine, ReminderLevel."No.");                            OnBeforeReminderLineInsert(ReminderLine, GlobalReminderHeader, ReminderLevel, GlobalCustLedgEntry, GlobalReminderHeaderReq);                            ReminderLine.Insert();                            StartLineInserted := true;                            AddLineFeeForCustLedgEntry(GlobalCustLedgEntry, ReminderLevel, NextLineNo);                        end;                    until GlobalCustLedgEntry.Next() = 0;                OnMakeReminderOnAfterReminderLevelLoop(ReminderLevel, NextLineNo, StartLineInserted, GlobalReminderHeaderReq, GlobalReminderHeader, GlobalCustomer);            until ReminderLevel.Next(-1) = 0;            OnAfterReminderLinesInsertLoop(GlobalReminderHeader, CurrencyCode, NextLineNo, MaxReminderLevel, OverdueEntriesOnly);            GlobalReminderHeader."Reminder Level" := MaxReminderLevel;            GlobalReminderHeader.Validate("Reminder Level");            OnMakeReminderOnBeforeReminderHeaderInsertLines(GlobalReminderHeader);            GlobalReminderHeader.InsertLines();            ReminderLine.SetRange("Reminder No.", GlobalReminderHeader."No.");            if ReminderLine.FindLast() then                NextLineNo := ReminderLine."Line No."            else                NextLineNo := 0;            GetOpenEntriesNotDueOnHoldTranslated(GlobalCustomer."Language Code", OpenEntriesNotDueTranslated, OpenEntriesOnHoldTranslated);            GlobalCustLedgEntry.SetRange("Last Issued Reminder Level");            OnMakeReminderOnBeforeCustLedgEntryFindSet(GlobalCustLedgEntry, GlobalCustomer, GlobalReminderHeader, MaxReminderLevel, OverdueEntriesOnly);            if GlobalCustLedgEntry.FindSet() then                repeat                    AddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilter(ReminderLine, ReminderLevel, LineLevel, ReminderDueDate, NextLineNo, OpenEntriesNotDueTranslated, StartLineInserted)                until GlobalCustLedgEntry.Next() = 0;            OnMakeReminderOnAfterAddRemiderLinesFromCustLedgEntriesWithNoReminderLevelFilter(GlobalCustLedgEntry, GlobalCustomer, GlobalReminderHeader, MaxReminderLevel, OverdueEntriesOnly);            if IncludeEntriesOnHold then                if TempCustLedgerEntryOnHold.FindSet() then begin                    InsertReminderLine(                      GlobalReminderHeader."No.", ReminderLine."Line Type"::"On Hold", '', NextLineNo);                    InsertReminderLine(                      GlobalReminderHeader."No.", ReminderLine."Line Type"::"On Hold", OpenEntriesOnHoldTranslated, NextLineNo);                    repeat                        InitReminderLine(                          ReminderLine, GlobalReminderHeader."No.", ReminderLine."Line Type"::"On Hold", '', NextLineNo);                        ReminderLine.Type := ReminderLine.Type::"Customer Ledger Entry";                        ReminderLine.Validate("Entry No.", TempCustLedgerEntryOnHold."Entry No.");                        ReminderLine."No. of Reminders" := 0;                        OnMakeReminderOnBeforeOnHoldReminderLineInsert(ReminderLine, GlobalReminderHeader, ReminderLevel, GlobalCustLedgEntry, TempCustLedgerEntryOnHold);                        ReminderLine.Insert();                    until TempCustLedgerEntryOnHold.Next() = 0;                end;            OnMakeReminderOnBeforeReminderHeaderModify(GlobalReminderHeader, ReminderLine, NextLineNo, MaxReminderLevel);            GlobalReminderHeader.Modify();        end;        RemoveLinesOfNegativeReminder(GlobalReminderHeader);        ReminderLevel.Reset();        GlobalCustLedgEntry.Reset();        OnAfterMakeReminder(GlobalReminderHeader, ReminderLine);        exit(true);    end;    local procedure AddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilter(var ReminderLine: Record "Reminder Line"; var ReminderLevel: Record "Reminder Level"; LineLevel: Integer; ReminderDueDate: Date; var NextLineNo: Integer; OpenEntriesNotDueTranslated: Text[100]; var StartLineInserted: Boolean)    var        IsHandled: Boolean;        IsGracePeriodExpired: Boolean;    begin        IsHandled := false;        OnBeforeAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilter(GlobalCustLedgEntry, GlobalReminderHeaderReq, GlobalReminderHeader, IsHandled, ReminderLine, NextLineNo, StartLineInserted);        if IsHandled then            exit;        if (not OverdueEntriesOnly) or           (GlobalCustLedgEntry."Document Type" in [GlobalCustLedgEntry."Document Type"::Payment, GlobalCustLedgEntry."Document Type"::Refund])        then begin            SetReminderLine(LineLevel, ReminderDueDate);            IsGracePeriodExpired :=                IsGracePeriodExpiredForOverdueEntry(ReminderDueDate, GlobalReminderHeaderReq."Document Date", ReminderLevel."Grace Period");            if (not IsGracePeriodExpired) and (LineLevel = 1) then begin                OnAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilterOnBeforeCheckAmountsNotDueLineInserted(                    GlobalReminderHeader, ReminderLine, AmountsNotDueLineInserted);                if not AmountsNotDueLineInserted then begin                    InsertReminderLine(GlobalReminderHeader."No.", ReminderLine."Line Type"::"Not Due", '', NextLineNo);                    InsertReminderLine(                      GlobalReminderHeader."No.", ReminderLine."Line Type"::"Not Due", OpenEntriesNotDueTranslated, NextLineNo);                    AmountsNotDueLineInserted := true;                end;                InitReminderLine(                  ReminderLine, GlobalReminderHeader."No.", ReminderLine."Line Type"::"Not Due", '', NextLineNo);                ReminderLine.Type := ReminderLine.Type::"Customer Ledger Entry";                ReminderLine.Validate("Entry No.", GlobalCustLedgEntry."Entry No.");                ReminderLine."No. of Reminders" := 0;                OnAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilterOnBeforeReminderLineInsert(ReminderLine, GlobalReminderHeader, ReminderLevel, GlobalCustLedgEntry);                ReminderLine.Insert();                AmountsNotDueLineInserted := true;                RemoveNotDueLinesInSectionReminderLine(ReminderLine);            end;        end;    end;    local procedure FindAndMarkReminderCandidates(var CustLedgEntry: Record "Cust. Ledger Entry"; var ReminderLevel: Record "Reminder Level"; var CustAmount: Decimal; var MakeDoc: Boolean; var MaxReminderLevel: Integer; var MaxLineLevel: Integer) Result: Boolean    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeFindAndMarkReminderCandidates(            ReminderLevel, GlobalReminderHeaderReq, GlobalReminderTerms, GlobalReminderEntry,            CustLedgEntry, TempCustLedgerEntryOnHold, CustLedgEntryLastIssuedReminderLevelFilter, CustAmount,            MakeDoc, MaxReminderLevel, MaxLineLevel, OverdueEntriesOnly, IncludeEntriesOnHold, IsHandled, Result);        if IsHandled then            exit(Result);        repeat            FilterCustLedgEntries(ReminderLevel);            if CustLedgEntry.FindSet() then                repeat                    IsHandled := false;                    OnFindAndMarkReminderCandidatesOnBeforeCustLedgEntryLoop(CustLedgEntry, GlobalReminderHeaderReq, IsHandled);                    if not IsHandled then                        if CustLedgEntry."On Hold" = '' then                            MarkReminderCandidate(CustLedgEntry, ReminderLevel, CustAmount, MakeDoc, MaxReminderLevel, MaxLineLevel, false)                        else // The customer ledger entry is on hold                            if IncludeEntriesOnHold then begin                                TempCustLedgerEntryOnHold := CustLedgEntry;                                if TempCustLedgerEntryOnHold.Insert() then;                                MarkReminderCandidate(CustLedgEntry, ReminderLevel, CustAmount, MakeDoc, MaxReminderLevel, MaxLineLevel, true);                            end;                until CustLedgEntry.Next() = 0;        until ReminderLevel.Next(-1) = 0;        IsHandled := false;        OnAfterFindAndMarkReminderCandidates(GlobalCustLedgEntry, ReminderLevel, CustAmount, MakeDoc, MaxReminderLevel, MaxLineLevel, IsHandled, Result);        if IsHandled then            exit(Result);        exit(true);    end;    local procedure MarkReminderCandidate(var CustLedgEntry: Record "Cust. Ledger Entry"; var ReminderLevel: Record "Reminder Level"; var CustAmount: Decimal; var MakeDoc: Boolean; var MaxReminderLevel: Integer; var MaxLineLevel: Integer; EntryOnHold: Boolean)    var        ReminderDueDate: Date;        LineLevel: Integer;        MarkEntry: Boolean;        IsHandled: Boolean;        IsGracePeriodExpired: Boolean;    begin        IsHandled := false;        OnBeforeMarkReminderCandidate(CustLedgEntry, IsHandled);        if IsHandled then            exit;        SetReminderLine(LineLevel, ReminderDueDate);        IsGracePeriodExpired := IsGracePeriodExpiredForOverdueEntry(ReminderDueDate, GlobalReminderHeaderReq."Document Date", ReminderLevel."Grace Period");        IsHandled := false;        OnMarkReminderCandidateOnAfterCalcIsGracePeriodExpired(ReminderLevel, ReminderDueDate, GlobalReminderHeaderReq, GlobalReminderTerms, CustLedgEntry, GlobalReminderHeader, LineLevel, IsGracePeriodExpired, IsHandled);        if IsHandled then            exit;        MarkEntry := false;        if IsGracePeriodExpired and           ((LineLevel <= GlobalReminderTerms."Max. No. of Reminders") or (GlobalReminderTerms."Max. No. of Reminders" = 0))        then begin            MarkEntry := true;            CustLedgEntry.CalcFields("Remaining Amount");            CustAmount += CustLedgEntry."Remaining Amount";            if CustLedgEntry.Positive and IsGracePeriodExpired then                MakeDoc := true;        end else            if not IsGracePeriodExpired and               (not OverdueEntriesOnly or                (CustLedgEntry."Document Type" in [CustLedgEntry."Document Type"::Payment, CustLedgEntry."Document Type"::Refund]))            then                MarkEntry := true;        if MarkEntry then begin            if not EntryOnHold then                CustLedgEntry.Mark(true);            ReminderLevel.Mark(true);            if (ReminderLevel."No." > MaxReminderLevel) and               (CustLedgEntry."Document Type" <> CustLedgEntry."Document Type"::"Credit Memo") and               IsGracePeriodExpired            then                MaxReminderLevel := ReminderLevel."No.";            if MaxLineLevel < LineLevel then                MaxLineLevel := LineLevel;        end;    end;    local procedure InsertReminderLine(ReminderNo: Code[50]; LineType: Enum "Reminder Line Type"; Description: Text[100]; var NextLineNo: Integer)    var        ReminderLine: Record "Reminder Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertReminderLine(ReminderNo, LineType, Description, NextLineNo, IsHandled);        if IsHandled then            exit;        InitReminderLine(ReminderLine, ReminderNo, LineType, Description, NextLineNo);        ReminderLine.Insert();    end;    local procedure InitReminderLine(var ReminderLine: Record "Reminder Line"; ReminderNo: Code[50]; LineType: Enum "Reminder Line Type"; Description: Text[100]; var NextLineNo: Integer)    begin        NextLineNo := GetLastLineNo(GlobalReminderHeader."No.") + 10000;        ReminderLine.Init();        ReminderLine."Reminder No." := CopyStr(ReminderNo, 1, MaxStrLen(ReminderLine."Reminder No."));        ReminderLine."Line No." := NextLineNo;        ReminderLine."Line Type" := LineType;        ReminderLine.Description := Description;        OnAfterInitReminderLine(GlobalReminderHeader, ReminderLine, LineType, Description);    end;    local procedure CustAmountLCY(CurrencyCode: Code[10]; Amount: Decimal): Decimal    var        CurrExchRate: Record "Currency Exchange Rate";    begin        if CurrencyCode <> '' then            exit(              CurrExchRate.ExchangeAmtFCYToLCY(                GlobalReminderHeaderReq."Posting Date", CurrencyCode, Amount,                CurrExchRate.ExchangeRate(GlobalReminderHeaderReq."Posting Date", CurrencyCode)));        exit(Amount);    end;    /// <summary>    /// Applies filters to customer ledger entries based on the specified reminder level.    /// </summary>    /// <param name="ReminderLevel2">Specifies the reminder level to filter customer ledger entries by.</param>    procedure FilterCustLedgEntries(var ReminderLevel2: Record "Reminder Level")    var        ReminderLevel3: Record "Reminder Level";        LastLevel: Boolean;    begin        if SkipCurrentReminderLevel(ReminderLevel2."No.") then begin            GlobalCustLedgEntry.SetRange("Last Issued Reminder Level", -1);            exit;        end;        ReminderLevel3 := ReminderLevel2;        ReminderLevel3.CopyFilters(ReminderLevel2);        if ReminderLevel3.Next() = 0 then            LastLevel := true        else            LastLevel := false;        if GlobalReminderTerms."Max. No. of Reminders" > 0 then            if ReminderLevel2."No." <= GlobalReminderTerms."Max. No. of Reminders" then                if LastLevel then                    GlobalCustLedgEntry.SetRange("Last Issued Reminder Level", ReminderLevel2."No." - 1, GlobalReminderTerms."Max. No. of Reminders" - 1)                else                    GlobalCustLedgEntry.SetRange("Last Issued Reminder Level", ReminderLevel2."No." - 1)            else                GlobalCustLedgEntry.SetRange("Last Issued Reminder Level", -1)        else            if LastLevel then                GlobalCustLedgEntry.SetFilter("Last Issued Reminder Level", '%1..', ReminderLevel2."No." - 1)            else                GlobalCustLedgEntry.SetRange("Last Issued Reminder Level", ReminderLevel2."No." - 1);    end;    local procedure SkipCurrentReminderLevel(ReminderLevelNo: Integer): Boolean    var        "Integer": Record "Integer";    begin        if CustLedgEntryLastIssuedReminderLevelFilter = '' then            exit(false);        Integer.SetFilter(Number, CustLedgEntryLastIssuedReminderLevelFilter);        Integer.FindSet();        if Integer.Number > ReminderLevelNo - 1 then            exit(true);        repeat            if Integer.Number = ReminderLevelNo - 1 then                exit(false)        until Integer.Next() = 0;        exit(true);    end;    local procedure FilterCustLedgEntryReminderLevel(var CustLedgEntry: Record "Cust. Ledger Entry"; var ReminderLevel: Record "Reminder Level"; CurrencyCode: Code[10])    begin        CustLedgEntry.SetCurrentKey("Customer No.", Open, Positive, "Due Date", "Currency Code");        CustLedgEntry.SetRange(Open, true);        CustLedgEntry.SetRange("Customer No.", GlobalCustomer."No.");        CustLedgEntry.SetRange("Currency Code", CurrencyCode);        ReminderLevel.SetRange("Reminder Terms Code", GlobalReminderTerms.Code);        OnAfterFilterCustLedgEntryReminderLevel(CustLedgEntry, ReminderLevel, GlobalReminderTerms, GlobalCustomer, GlobalReminderHeaderReq, GlobalReminderHeader);    end;    /// <summary>    /// Calculates the reminder level and due date for a customer ledger entry based on previous reminder history.    /// </summary>    /// <param name="LineLevel2">Returns the calculated reminder level for the entry.</param>    /// <param name="ReminderDueDate2">Returns the due date for the reminder entry.</param>    procedure SetReminderLine(var LineLevel2: Integer; var ReminderDueDate2: Date)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetReminderLine(LineLevel2, ReminderDueDate2, IsHandled, GlobalCustLedgEntry, GlobalReminderEntry);        if not IsHandled then begin            if GlobalCustLedgEntry."Last Issued Reminder Level" > 0 then begin                GlobalReminderEntry.SetCurrentKey("Customer Entry No.", Type);                GlobalReminderEntry.SetRange("Customer Entry No.", GlobalCustLedgEntry."Entry No.");                GlobalReminderEntry.SetRange(Type, GlobalReminderEntry.Type::Reminder);                GlobalReminderEntry.SetRange("Reminder Level", GlobalCustLedgEntry."Last Issued Reminder Level");                GlobalReminderEntry.SetRange(Canceled, false);                OnSetReminderLineOnAfterSetFilters(GlobalReminderEntry);                if GlobalReminderEntry.FindLast() then begin                    ReminderDueDate2 := GlobalReminderEntry."Due Date";                    LineLevel2 := GlobalReminderEntry."Reminder Level" + 1;                    OnSetReminderLineOnAfterFindNextLineLevel(GlobalReminderEntry, LineLevel2, ReminderDueDate2);                    exit;                end            end;            ReminderDueDate2 := GlobalCustLedgEntry."Due Date";            LineLevel2 := 1;        end;        OnAfterSetReminderLine(GlobalCustLedgEntry, LineLevel2, ReminderDueDate2);    end;    /// <summary>    /// Adds a line fee for a customer ledger entry if applicable based on reminder level settings.    /// </summary>    /// <param name="CustLedgEntry">Specifies the customer ledger entry to add a line fee for.</param>    /// <param name="ReminderLevel">Specifies the reminder level containing the line fee settings.</param>    /// <param name="NextLineNo">Specifies the next line number to use for the reminder line.</param>    procedure AddLineFeeForCustLedgEntry(var CustLedgEntry: Record "Cust. Ledger Entry"; var ReminderLevel: Record "Reminder Level"; NextLineNo: Integer)    var        TempCustLedgEntry: Record "Cust. Ledger Entry" temporary;        ReminderLine: Record "Reminder Line";        IssuedReminderLine: Record "Issued Reminder Line";        CustPostingGr: Record "Customer Posting Group";        LineFeeAmount: Decimal;    begin        TempCustLedgEntry := CustLedgEntry;        TempCustLedgEntry.Insert();        TempCustLedgEntry.Reset();        TempCustLedgEntry.CopyFilters(GlobalCustLedgEntryLineFeeFilters);        if TempCustLedgEntry.IsEmpty() then            exit;        CustLedgEntry.CalcFields("Remaining Amount");        OnAddLineFeeForCustLedgEntryOnAfterCalcRemainingAmount(CustLedgEntry);        LineFeeAmount := ReminderLevel.GetAdditionalFee(CustLedgEntry."Remaining Amount",            GlobalReminderHeader."Currency Code", true, GlobalReminderHeader."Posting Date");        if LineFeeAmount = 0 then            exit;        IssuedReminderLine.SetRange(Type, IssuedReminderLine.Type::"Line Fee");        IssuedReminderLine.SetRange("Applies-To Document Type", CustLedgEntry."Document Type");        IssuedReminderLine.SetRange("Applies-To Document No.", CustLedgEntry."Document No.");        IssuedReminderLine.SetRange("No. of Reminders", ReminderLevel."No.");        IssuedReminderLine.SetRange(Canceled, false);        if not IssuedReminderLine.IsEmpty() then            exit;        CustPostingGr.Get(GlobalReminderHeader."Customer Posting Group");        NextLineNo := NextLineNo + 100;        ReminderLine.Init();        ReminderLine.Validate("Reminder No.", GlobalReminderHeader."No.");        ReminderLine.Validate("Line No.", NextLineNo);        ReminderLine.Validate(Type, ReminderLine.Type::"Line Fee");        ReminderLine.Validate("No.", CustPostingGr.GetAddFeePerLineAccount());        ReminderLine.Validate("No. of Reminders", ReminderLevel."No.");        ReminderLine.Validate("Applies-to Document Type", CustLedgEntry."Document Type");        ReminderLine.Validate("Applies-to Document No.", CustLedgEntry."Document No.");        ReminderLine.Validate("Due Date", CalcDate(ReminderLevel."Due Date Calculation", GlobalReminderHeader."Document Date"));        OnAddLineFeeForCustLedgEntryOnReminderLineInsert(ReminderLine);        ReminderLine.Insert(true);    end;    internal procedure EmitCreateReminderTelemetry()    begin        FeatureTelemetry.LogUptake('0000LB0', 'Reminder', Enum::"Feature Uptake Status"::"Set up");        FeatureTelemetry.LogUptake('0000LB1', 'Reminder', Enum::"Feature Uptake Status"::Used);        FeatureTelemetry.LogUsage('0000LB2', 'Reminder', 'Make Reminder called.');    end;    local procedure GetLastLineNo(ReminderNo: Code[50]): Integer    var        ReminderLineExtra: Record "Reminder Line";    begin        ReminderLineExtra.SetRange("Reminder No.", ReminderNo);        if ReminderLineExtra.FindLast() then;        exit(ReminderLineExtra."Line No.");    end;    local procedure SetReminderLevel(ReminderHeader: Record "Reminder Header"; var ReminderLine: Record "Reminder Line"; LineLevel: Integer)    begin        if ReminderHeader."Use Header Level" then            ReminderLine."No. of Reminders" := ReminderHeader."Reminder Level"        else            ReminderLine."No. of Reminders" := LineLevel;    end;    local procedure RemoveLinesOfNegativeReminder(var ReminderHeader: Record "Reminder Header")    var        ReminderTotal: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRemoveLinesOfNegativeReminder(ReminderHeader, GlobalReminderHeaderReq, GlobalCustomer, IsHandled);        if IsHandled then            exit;        ReminderHeader.CalcFields(          "Remaining Amount", "Interest Amount", "Additional Fee", "VAT Amount");        ReminderTotal := ReminderHeader."Remaining Amount" + ReminderHeader."Interest Amount" +          ReminderHeader."Additional Fee" + ReminderHeader."VAT Amount";        if ReminderTotal < 0 then            ReminderHeader.Delete(true);    end;    local procedure GetOpenEntriesNotDueOnHoldTranslated(CustomerLanguageCode: Code[10]; var OpenEntriesNotDueTranslated: Text[100]; var OpenEntriesOnHoldTranslated: Text[100])    var        Language: Codeunit Language;        CurrentLanguageCode: Integer;    begin        if CustomerLanguageCode <> '' then begin            CurrentLanguageCode := GlobalLanguage;            GlobalLanguage(Language.GetLanguageIdOrDefault(CustomerLanguageCode));            OpenEntriesNotDueTranslated := OpenEntriesNotDueLbl;            OpenEntriesOnHoldTranslated := OpenEntriesOnHoldLbl;            GlobalLanguage(CurrentLanguageCode);        end else begin            OpenEntriesNotDueTranslated := OpenEntriesNotDueLbl;            OpenEntriesOnHoldTranslated := OpenEntriesOnHoldLbl;        end;    end;    local procedure RemoveNotDueLinesInSectionReminderLine(ReminderLine: Record "Reminder Line")    var        ReminderLineToDelete: Record "Reminder Line";    begin        ReminderLineToDelete.SetRange("Reminder No.", ReminderLine."Reminder No.");        ReminderLineToDelete.SetRange(Type, ReminderLine.Type);        ReminderLineToDelete.SetRange("Entry No.", ReminderLine."Entry No.");        ReminderLineToDelete.SetRange("Document Type", ReminderLine."Document Type");        ReminderLineToDelete.SetRange("Document No.", ReminderLine."Document No.");        ReminderLineToDelete.SetFilter("Line Type", '<>%1', ReminderLine."Line Type");        if ReminderLineToDelete.FindFirst() then            ReminderLineToDelete.Delete(true);    end;    local procedure CheckCustomerIsBlocked(Customer: Record Customer) Result: Boolean    begin        Result := Customer.Blocked = Customer.Blocked::All;        OnAfterCheckCustomerIsBlocked(Customer, Result);    end;    local procedure IsGracePeriodExpiredForOverdueEntry(DueDate: Date; ReminderDocumentDate: Date; GracePeriod: DateFormula): Boolean    begin        exit(CalcDate(GracePeriod, DueDate) < ReminderDocumentDate);    end;    /// <summary>    /// Raised after the reminder creation process completes.    /// </summary>    /// <param name="RetVal">Indicates whether at least one reminder was created successfully.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCode(var RetVal: Boolean)    begin    end;    /// <summary>    /// Raised after filters are applied to customer ledger entries based on reminder level.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry record being filtered.</param>    /// <param name="ReminderLevel">The reminder level used for filtering.</param>    /// <param name="ReminderTerms">The reminder terms configuration.</param>    /// <param name="Customer">The customer record for the reminder.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="ReminderHeader">The reminder header being created.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterFilterCustLedgEntryReminderLevel(var CustLedgerEntry: Record "Cust. Ledger Entry"; var ReminderLevel: Record "Reminder Level"; ReminderTerms: Record "Reminder Terms"; Customer: Record Customer; ReminderHeaderReq: Record "Reminder Header"; ReminderHeader: Record "Reminder Header")    begin    end;    /// <summary>    /// Raised after a reminder line is initialized with default values.    /// </summary>    /// <param name="ReminderHeader">The reminder header for the line.</param>    /// <param name="ReminderLine">The initialized reminder line.</param>    /// <param name="LineType">The type of the reminder line.</param>    /// <param name="Description">The description for the reminder line.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInitReminderLine(var ReminderHeader: Record "Reminder Header"; var ReminderLine: Record "Reminder Line"; LineType: Enum "Reminder Line Type"; Description: Text)    begin    end;    /// <summary>    /// Raised after a reminder document is created with all its lines.    /// </summary>    /// <param name="ReminderHeader">The completed reminder header.</param>    /// <param name="ReminderLine">The last reminder line processed.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterMakeReminder(var ReminderHeader: Record "Reminder Header"; var ReminderLine: Record "Reminder Line")    begin    end;    /// <summary>    /// Raised after the reminder creation parameters are set.    /// </summary>    /// <param name="Cust">The customer for reminder creation.</param>    /// <param name="CustLedgEntry">The customer ledger entries filter.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries are included.</param>    /// <param name="IncludeEntriesOnHold">Indicates whether entries on hold are included.</param>    /// <param name="CustLedgEntryLinefeeOn">The customer ledger entries filter for line fees.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSet(var Cust: Record Customer; var CustLedgEntry: Record "Cust. Ledger Entry"; var ReminderHeaderReq: Record "Reminder Header"; var OverdueEntriesOnly: Boolean; var IncludeEntriesOnHold: Boolean; var CustLedgEntryLinefeeOn: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Raised after the reminder level and due date are calculated for a customer ledger entry.    /// </summary>    /// <param name="CustLedgEntry">The customer ledger entry being processed.</param>    /// <param name="LineLevel2">The calculated reminder level for the entry.</param>    /// <param name="ReminderDueDate2">The calculated due date for the reminder.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSetReminderLine(CustLedgEntry: Record "Cust. Ledger Entry"; var LineLevel2: Integer; var ReminderDueDate2: Date)    begin    end;    /// <summary>    /// Raised after the suggest lines parameters are set for an existing reminder.    /// </summary>    /// <param name="ReminderHeader">The reminder header to add lines to.</param>    /// <param name="CustLedgEntry2">The customer ledger entries filter.</param>    /// <param name="OverdueEntriesOnly2">Indicates whether only overdue entries are included.</param>    /// <param name="IncludeEntriesOnHold2">Indicates whether entries on hold are included.</param>    /// <param name="CustLedgEntryLinefeeOn">The customer ledger entries filter for line fees.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSuggestLines(ReminderHeader: Record "Reminder Header"; var CustLedgEntry2: Record "Cust. Ledger Entry"; OverdueEntriesOnly2: Boolean; IncludeEntriesOnHold2: Boolean; var CustLedgEntryLinefeeOn: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Raised after the remaining amount is calculated for a customer ledger entry when adding line fees.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry with calculated remaining amount.</param>    [IntegrationEvent(false, false)]    local procedure OnAddLineFeeForCustLedgEntryOnAfterCalcRemainingAmount(var CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Raised before inserting a line fee reminder line.    /// </summary>    /// <param name="ReminderLine">The line fee reminder line to be inserted.</param>    [IntegrationEvent(false, false)]    local procedure OnAddLineFeeForCustLedgEntryOnReminderLineInsert(var ReminderLine: Record "Reminder Line")    begin    end;    /// <summary>    /// Raised before checking if the amounts not due line has been inserted.    /// </summary>    /// <param name="ReminderHeader">The reminder header being processed.</param>    /// <param name="ReminderLine">The current reminder line.</param>    /// <param name="AmountsNotDueLineInserted">Indicates whether the amounts not due line has been inserted.</param>    [IntegrationEvent(false, false)]    local procedure OnAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilterOnBeforeCheckAmountsNotDueLineInserted(ReminderHeader: Record "Reminder Header"; ReminderLine: Record "Reminder Line"; var AmountsNotDueLineInserted: Boolean)    begin    end;    /// <summary>    /// Raised before adding reminder lines from customer ledger entries with no reminder level filter.    /// </summary>    /// <param name="CustLedgEntry">The customer ledger entry to add.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="ReminderHeader">The reminder header being created.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    /// <param name="ReminderLine">The reminder line being created.</param>    /// <param name="NextLineNo">The next line number to use.</param>    /// <param name="StartLineInserted">Indicates whether a start line was inserted.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilter(var CustLedgEntry: Record "Cust. Ledger Entry"; ReminderHeaderReq: Record "Reminder Header"; ReminderHeader: Record "Reminder Header"; var IsHandled: Boolean; var ReminderLine: Record "Reminder Line"; var NextLineNo: Integer; var StartLineInserted: Boolean)    begin    end;    /// <summary>    /// Raised before finding customer ledger entries for reminder creation.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry record to search.</param>    /// <param name="ReminderHeader">The reminder header request parameters.</param>    /// <param name="Customer">The customer for the reminder.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCustLedgerEntryFind(var CustLedgerEntry: Record "Cust. Ledger Entry"; ReminderHeader: Record "Reminder Header"; Customer: Record Customer)    begin    end;    /// <summary>    /// Raised before retrieving the reminder terms for a customer.    /// </summary>    /// <param name="ReminderHeader">The reminder header being processed.</param>    /// <param name="ReminderTerms">The reminder terms to retrieve.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetReminderTerms(var ReminderHeader: Record "Reminder Header"; var ReminderTerms: Record "Reminder Terms"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before finding and marking customer ledger entries as reminder candidates.    /// </summary>    /// <param name="ReminderLevel">The reminder level configuration.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="ReminderTerms">The reminder terms configuration.</param>    /// <param name="ReminderEntry">The reminder entry record for history lookup.</param>    /// <param name="CustLedgEntry">The customer ledger entries to process.</param>    /// <param name="TempCustLedgEntryOnHold">Temporary table for entries on hold.</param>    /// <param name="CustLedgEntryLastIssuedReminderLevelFilter">Filter for last issued reminder level.</param>    /// <param name="CustAmount">The cumulative customer amount.</param>    /// <param name="MakeDoc">Indicates whether to create a reminder document.</param>    /// <param name="MaxReminderLevel">The maximum reminder level found.</param>    /// <param name="MaxLineLevel">The maximum line level found.</param>    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries are included.</param>    /// <param name="IncludeEntriesOnHold">Indicates whether entries on hold are included.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    /// <param name="Result">Returns the result when handling is skipped.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeFindAndMarkReminderCandidates(var ReminderLevel: Record "Reminder Level"; ReminderHeaderReq: Record "Reminder Header"; ReminderTerms: Record "Reminder Terms"; var ReminderEntry: Record "Reminder/Fin. Charge Entry"; var CustLedgEntry: Record "Cust. Ledger Entry"; var TempCustLedgEntryOnHold: Record "Cust. Ledger Entry" temporary; var CustLedgEntryLastIssuedReminderLevelFilter: Text; var CustAmount: Decimal; var MakeDoc: Boolean; var MaxReminderLevel: Integer; var MaxLineLevel: Integer; OverdueEntriesOnly: Boolean; IncludeEntriesOnHold: Boolean; var IsHandled: Boolean; var Result: Boolean)    begin    end;    /// <summary>    /// Raised before inserting a reminder line.    /// </summary>    /// <param name="ReminderNo">The reminder document number.</param>    /// <param name="LineType">The type of the reminder line.</param>    /// <param name="Description">The description for the line.</param>    /// <param name="NextLineNo">The next line number to use.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertReminderLine(ReminderNo: Code[20]; LineType: Enum "Reminder Line Type"; Description: Text[100]; var NextLineNo: Integer; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before creating a reminder for a specific currency.    /// </summary>    /// <param name="ReminderHeader">The reminder header to create.</param>    /// <param name="CurrencyCode">The currency code for the reminder.</param>    /// <param name="RetVal">Returns the result when handling is skipped.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries are included.</param>    /// <param name="IncludeEntriesOnHold">Indicates whether entries on hold are included.</param>    /// <param name="HeaderExists">Indicates whether a reminder header already exists.</param>    /// <param name="Customer">The customer for the reminder.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeMakeReminder(var ReminderHeader: Record "Reminder Header"; CurrencyCode: Code[10]; var RetVal: Boolean; var IsHandled: Boolean; ReminderHeaderReq: Record "Reminder Header"; OverdueEntriesOnly: Boolean; IncludeEntriesOnHold: Boolean; HeaderExists: Boolean; Customer: Record Customer)    begin    end;    /// <summary>    /// Raised before marking a customer ledger entry as a reminder candidate.    /// </summary>    /// <param name="CustLedgEntry">The customer ledger entry to evaluate.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeMarkReminderCandidate(var CustLedgEntry: Record "Cust. Ledger Entry"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before removing lines from a reminder with negative total amount.    /// </summary>    /// <param name="ReminderHeader">The reminder header to evaluate.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="Customer">The customer for the reminder.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeRemoveLinesOfNegativeReminder(var ReminderHeader: Record "Reminder Header"; ReminderHeaderReq: Record "Reminder Header"; Customer: Record Customer; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before finding an existing reminder header for the customer and currency.    /// </summary>    /// <param name="ReminderHeader">The reminder header record to search.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="ReminderTerms">The reminder terms configuration.</param>    /// <param name="Customer">The customer for the reminder.</param>    /// <param name="CustLedgerEntry">The customer ledger entry being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeReminderHeaderFind(var ReminderHeader: Record "Reminder Header"; ReminderHeaderReq: Record "Reminder Header"; ReminderTerms: Record "Reminder Terms"; Customer: Record Customer; CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Raised before inserting a new reminder header.    /// </summary>    /// <param name="ReminderHeader">The reminder header to insert.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="ReminderTerms">The reminder terms configuration.</param>    /// <param name="Customer">The customer for the reminder.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeReminderHeaderInsert(var ReminderHeader: Record "Reminder Header"; ReminderHeaderReq: Record "Reminder Header"; ReminderTerms: Record "Reminder Terms"; Customer: Record Customer)    begin    end;    /// <summary>    /// Raised before modifying the reminder header with reminder level and other settings.    /// </summary>    /// <param name="ReminderHeader">The reminder header to modify.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="HeaderExists">Indicates whether the header already existed.</param>    /// <param name="ReminderTerms">The reminder terms configuration.</param>    /// <param name="Customer">The customer for the reminder.</param>    /// <param name="ReminderLevel">The reminder level being applied.</param>    /// <param name="CustLedgerEntry">The customer ledger entries being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeReminderHeaderModify(var ReminderHeader: Record "Reminder Header"; var ReminderHeaderReq: Record "Reminder Header"; HeaderExists: Boolean; ReminderTerms: Record "Reminder Terms"; Customer: Record Customer; ReminderLevel: Record "Reminder Level"; var CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Raised before inserting a reminder line for a customer ledger entry.    /// </summary>    /// <param name="ReminderLine">The reminder line to insert.</param>    /// <param name="ReminderHeader">The reminder header for the line.</param>    /// <param name="ReminderLevel">The reminder level for the line.</param>    /// <param name="CustLedgerEntry">The customer ledger entry for the line.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeReminderLineInsert(var ReminderLine: Record "Reminder Line"; ReminderHeader: Record "Reminder Header"; ReminderLevel: Record "Reminder Level"; CustLedgerEntry: Record "Cust. Ledger Entry"; ReminderHeaderReq: Record "Reminder Header")    begin    end;    /// <summary>    /// Raised before processing reminders for each currency.    /// </summary>    /// <param name="CustLedgEntry">The customer ledger entries to process.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="ReminderTerms">The reminder terms configuration.</param>    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries are included.</param>    /// <param name="IncludeEntriesOnHold">Indicates whether entries on hold are included.</param>    /// <param name="HeaderExists">Indicates whether a reminder header already exists.</param>    /// <param name="CustLedgEntryLastIssuedReminderLevelFilter">Filter for last issued reminder level.</param>    /// <param name="TempCurrency">Temporary table of currencies to process.</param>    /// <param name="Customer">The customer for the reminder.</param>    /// <param name="CustLedgEntryLineFeeFilters">The customer ledger entries filter for line fees.</param>    [IntegrationEvent(false, false)]    local procedure OnCodeOnBeforeCurrencyLoop(CustLedgEntry: Record "Cust. Ledger Entry"; ReminderHeaderReq: Record "Reminder Header"; ReminderTerms: Record "Reminder Terms"; OverdueEntriesOnly: Boolean; IncludeEntriesOnHold: Boolean; HeaderExists: Boolean; CustLedgEntryLastIssuedReminderLevelFilter: Text; var TempCurrency: Record Currency temporary; Customer: Record Customer; var CustLedgEntryLineFeeFilters: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Raised before retrieving reminder terms for processing.    /// </summary>    /// <param name="Customer">The customer to get reminder terms for.</param>    /// <param name="CustLedgerEntry">The customer ledger entries being processed.</param>    /// <param name="CustLedgEntryLastIssuedReminderLevelFilter">Filter for last issued reminder level.</param>    /// <param name="ReminderHeader">The reminder header being processed.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    /// <param name="ReturnValue">Returns the result when handling is skipped.</param>    [IntegrationEvent(false, false)]    local procedure OnCodeOnBeforeGetReminderTerms(var Customer: Record Customer; var CustLedgerEntry: Record "Cust. Ledger Entry"; var CustLedgEntryLastIssuedReminderLevelFilter: Text; var ReminderHeader: Record "Reminder Header"; var IsHandled: Boolean; var ReturnValue: Boolean)    begin    end;    /// <summary>    /// Raised before processing each customer ledger entry in the reminder candidate loop.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry being processed.</param>    /// <param name="ReminderHeader">The reminder header request parameters.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnFindAndMarkReminderCandidatesOnBeforeCustLedgEntryLoop(var CustLedgerEntry: Record "Cust. Ledger Entry"; var ReminderHeader: Record "Reminder Header"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised after finding and marking reminder candidates from customer ledger entries.    /// </summary>    /// <param name="CustLedgEntry">The customer ledger entries processed.</param>    /// <param name="ReminderLevel">The reminder level configuration.</param>    /// <param name="CustAmount">The cumulative customer amount.</param>    /// <param name="MakeDoc">Indicates whether to create a reminder document.</param>    /// <param name="MaxReminderLevel">The maximum reminder level found.</param>    /// <param name="MaxLineLevel">The maximum line level found.</param>    /// <param name="IsHandled">Set to true to skip default result.</param>    /// <param name="Result">Returns the result when handling is skipped.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterFindAndMarkReminderCandidates(CustLedgEntry: Record "Cust. Ledger Entry"; ReminderLevel: Record "Reminder Level"; var CustAmount: Decimal; MakeDoc: Boolean; MaxReminderLevel: Integer; MaxLineLevel: Integer; var IsHandled: Boolean; var Result: Boolean)    begin    end;    /// <summary>    /// Raised after calculating whether a reminder document should be created.    /// </summary>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="ReminderHeader">The reminder header being created.</param>    /// <param name="Customer">The customer for the reminder.</param>    /// <param name="ShouldMakeDoc">Indicates whether a reminder document should be created.</param>    /// <param name="MakeDoc">The original make document flag.</param>    /// <param name="CustLedgerEntry">The customer ledger entries being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnMakeReminderOnAfterCalcShouldMakeDoc(ReminderHeaderReq: Record "Reminder Header"; ReminderHeader: Record "Reminder Header"; Customer: Record Customer; var ShouldMakeDoc: Boolean; MakeDoc: Boolean; var CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Raised after adding reminder lines from customer ledger entries with no reminder level filter.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entries processed.</param>    /// <param name="Customer">The customer for the reminder.</param>    /// <param name="ReminderHeader">The reminder header being created.</param>    /// <param name="MaxReminderLevel">The maximum reminder level.</param>    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries are included.</param>    [IntegrationEvent(false, false)]    local procedure OnMakeReminderOnAfterAddRemiderLinesFromCustLedgEntriesWithNoReminderLevelFilter(var CustLedgerEntry: Record "Cust. Ledger Entry"; Customer: Record Customer; ReminderHeader: Record "Reminder Header"; MaxReminderLevel: Integer; var OverdueEntriesOnly: Boolean)    begin    end;    /// <summary>    /// Raised after processing each reminder level in the reminder creation loop.    /// </summary>    /// <param name="ReminderLevel">The reminder level processed.</param>    /// <param name="NextLineNo">The next line number available.</param>    /// <param name="StartLineInserted">Indicates whether a start line was inserted.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="ReminderHeader">The reminder header being created.</param>    /// <param name="Customer">The customer for the reminder.</param>    [IntegrationEvent(false, false)]    local procedure OnMakeReminderOnAfterReminderLevelLoop(var ReminderLevel: Record "Reminder Level"; var NextLineNo: Integer; StartLineInserted: Boolean; ReminderHeaderReq: Record "Reminder Header"; ReminderHeader: Record "Reminder Header"; Customer: Record Customer)    begin    end;    /// <summary>    /// Raised after calculating whether the grace period has expired for an overdue entry.    /// </summary>    /// <param name="ReminderDueDate">The due date of the reminder entry.</param>    /// <param name="ReminderHeader">The reminder header request parameters.</param>    /// <param name="IsGracePeriodExpired">Indicates whether the grace period has expired.</param>    [IntegrationEvent(false, false)]    local procedure OnMakeReminderOnAfterCalcIsGracePeriodExpired(var ReminderDueDate: Date; var ReminderHeader: Record "Reminder Header"; var IsGracePeriodExpired: Boolean)    begin    end;    /// <summary>    /// Raised before finding customer ledger entries for processing in the reminder creation.    /// </summary>    /// <param name="CustLedgEntry">The customer ledger entry record to search.</param>    /// <param name="Cust">The customer for the reminder.</param>    /// <param name="ReminderHeader">The reminder header being created.</param>    /// <param name="MaxReminderLevel">The maximum reminder level.</param>    /// <param name="OverDueEntriesOnly">Indicates whether only overdue entries are included.</param>    [IntegrationEvent(false, false)]    local procedure OnMakeReminderOnBeforeCustLedgEntryFindSet(var CustLedgEntry: Record "Cust. Ledger Entry"; Cust: Record Customer; ReminderHeader: Record "Reminder Header"; MaxReminderLevel: Integer; var OverDueEntriesOnly: Boolean)    begin    end;    /// <summary>    /// Raised before inserting a reminder line for an on-hold customer ledger entry.    /// </summary>    /// <param name="ReminderLine">The reminder line to insert.</param>    /// <param name="ReminderHeader">The reminder header for the line.</param>    /// <param name="ReminderLevel">The reminder level configuration.</param>    /// <param name="CustLedgerEntry">The customer ledger entries being processed.</param>    /// <param name="CustLedgEntryOnHoldTEMP">Temporary table of entries on hold.</param>    [IntegrationEvent(false, false)]    local procedure OnMakeReminderOnBeforeOnHoldReminderLineInsert(var ReminderLine: Record "Reminder Line"; ReminderHeader: Record "Reminder Header"; ReminderLevel: Record "Reminder Level"; var CustLedgerEntry: Record "Cust. Ledger Entry"; var CustLedgEntryOnHoldTEMP: Record "Cust. Ledger Entry" temporary)    begin    end;    /// <summary>    /// Raised before modifying the reminder header after all lines are processed.    /// </summary>    /// <param name="ReminderHeader">The reminder header to modify.</param>    /// <param name="ReminderLine">The last reminder line processed.</param>    /// <param name="NextLineNo">The next line number available.</param>    /// <param name="MaxReminderLevel">The maximum reminder level.</param>    [IntegrationEvent(false, false)]    local procedure OnMakeReminderOnBeforeReminderHeaderModify(var ReminderHeader: Record "Reminder Header"; var ReminderLine: Record "Reminder Line"; var NextLineNo: Integer; MaxReminderLevel: Integer)    begin    end;    /// <summary>    /// Raised after calculating whether the grace period has expired when marking reminder candidates.    /// </summary>    /// <param name="ReminderLevel">The reminder level configuration.</param>    /// <param name="ReminderDueDate">The due date of the reminder entry.</param>    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>    /// <param name="ReminderTerms">The reminder terms configuration.</param>    /// <param name="CustLedgerEntry">The customer ledger entry being evaluated.</param>    /// <param name="ReminderHeader">The reminder header being created.</param>    /// <param name="LineLevel">The calculated line level.</param>    /// <param name="IsGracePeriodExpired">Indicates whether the grace period has expired.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnMarkReminderCandidateOnAfterCalcIsGracePeriodExpired(var ReminderLevel: Record "Reminder Level"; var ReminderDueDate: Date; var ReminderHeaderReq: Record "Reminder Header"; var ReminderTerms: Record "Reminder Terms"; var CustLedgerEntry: Record "Cust. Ledger Entry"; var ReminderHeader: Record "Reminder Header"; var LineLevel: Integer; var IsGracePeriodExpired: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised after setting filters on the reminder entry record when calculating reminder level.    /// </summary>    /// <param name="ReminderFinChargeEntry">The reminder entry record with filters applied.</param>    [IntegrationEvent(false, false)]    local procedure OnSetReminderLineOnAfterSetFilters(var ReminderFinChargeEntry: Record "Reminder/Fin. Charge Entry")    begin    end;    /// <summary>    /// Raised after finding the next line level from the reminder entry history.    /// </summary>    /// <param name="ReminderEntry">The reminder entry record found.</param>    /// <param name="LineLevel2">The calculated next line level.</param>    /// <param name="ReminderDueDate2">The due date from the reminder entry.</param>    [IntegrationEvent(false, false)]    local procedure OnSetReminderLineOnAfterFindNextLineLevel(ReminderEntry: Record "Reminder/Fin. Charge Entry"; var LineLevel2: Integer; var ReminderDueDate2: Date)    begin    end;    /// <summary>    /// Raised before inserting a reminder line for entries not due with no reminder level filter.    /// </summary>    /// <param name="ReminderLine">The reminder line to insert.</param>    /// <param name="ReminderHeader">The reminder header for the line.</param>    /// <param name="ReminderLevel">The reminder level configuration.</param>    /// <param name="CustLedgerEntry">The customer ledger entry for the line.</param>    [IntegrationEvent(false, false)]    local procedure OnAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilterOnBeforeReminderLineInsert(var ReminderLine: Record "Reminder Line"; ReminderHeader: Record "Reminder Header"; ReminderLevel: Record "Reminder Level"; var CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Raised after checking if a customer is blocked.    /// </summary>    /// <param name="Customer">The customer record that was checked.</param>    /// <param name="Result">Returns whether the customer is blocked.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckCustomerIsBlocked(Customer: Record Customer; var Result: Boolean)    begin    end;    /// <summary>    /// Raised after filtering customer ledger entries in the make reminder process.    /// </summary>    /// <param name="ReminderLine">The reminder line being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnMakeReminderOnAfterFilterCustLedgEntries(var ReminderLine: Record "Reminder Line")    begin    end;    /// <summary>    /// Raised before the reminder header inserts its standard lines.    /// </summary>    /// <param name="ReminderHeader">The reminder header about to insert lines.</param>    [IntegrationEvent(false, false)]    local procedure OnMakeReminderOnBeforeReminderHeaderInsertLines(var ReminderHeader: Record "Reminder Header")    begin    end;    /// <summary>    /// Raised before setting the reminder line level and due date.    /// </summary>    /// <param name="LineLevel2">The line level to be set.</param>    /// <param name="ReminderDueDate2">The reminder due date to be set.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    /// <param name="CustLedgerEntry">The customer ledger entry being processed.</param>    /// <param name="ReminderFinChargeEntry">The reminder entry record for history lookup.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSetReminderLine(var LineLevel2: Integer; var ReminderDueDate2: Date; var IsHandled: Boolean; var CustLedgerEntry: Record "Cust. Ledger Entry"; var ReminderFinChargeEntry: Record "Reminder/Fin. Charge Entry")    begin    end;    /// <summary>    /// Raised after inserting all reminder lines in the loop.    /// </summary>    /// <param name="ReminderHeader">The reminder header with inserted lines.</param>    /// <param name="CurrencyCode">The currency code for the reminder.</param>    /// <param name="NextLineNo">The next available line number.</param>    /// <param name="MaxReminderLevel">The maximum reminder level applied.</param>    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries were included.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterReminderLinesInsertLoop(var ReminderHeader: Record "Reminder Header"; CurrencyCode: Code[10]; var NextLineNo: Integer; var MaxReminderLevel: Integer; OverdueEntriesOnly: Boolean);    begin    end;    /// <summary>    /// Raised after retrieving the customer for an existing reminder header.    /// </summary>    /// <param name="ReminderHeader">The reminder header being processed.</param>    /// <param name="Customer">The customer retrieved for the reminder.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    /// <param name="ReturnValue">Returns the result when handling is skipped.</param>    [IntegrationEvent(false, false)]    local procedure OnCodeOnAfterGlobalReminderGetGlobalCustomer(var ReminderHeader: Record "Reminder Header"; var Customer: Record Customer; var IsHandled: Boolean; var ReturnValue: Boolean)    begin    end;}