Codeunit 226 CustEntry-Apply Posted Entries

Base Application, Microsoft.Sales.Receivables

src/Layers/W1/BaseApp/Sales/Receivables/CustEntryApplyPostedEntries.Codeunit.al1,038 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.Receivables;using Microsoft.Finance.Analysis;using Microsoft.Finance.Currency;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Ledger;using Microsoft.Finance.GeneralLedger.Posting;using Microsoft.Finance.GeneralLedger.Preview;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Finance.ReceivablesPayables;using Microsoft.Foundation.AuditCodes;using Microsoft.Foundation.NoSeries;using Microsoft.Foundation.Period;/// <summary>/// Processes the application and unapplication of posted customer ledger entries, enabling payment matching and reversal operations./// </summary>codeunit 226 "CustEntry-Apply Posted Entries"{    EventSubscriberInstance = Manual;    Permissions = TableData "Cust. Ledger Entry" = rimd;    TableNo = "Cust. Ledger Entry";    trigger OnRun()    var        ApplyUnapplyParameters: Record "Apply Unapply Parameters";        SequenceNoMgt: Codeunit "Sequence No. Mgt.";    begin        SequenceNoMgt.SetPreviewMode(PreviewMode);        if PreviewMode then            case RunOptionPreviewContext of                RunOptionPreview::Apply:                    Apply(Rec, ApplyUnapplyParametersContext);                RunOptionPreview::Unapply:                    PostUnApplyCustomer(DetailedCustLedgEntryPreviewContext, ApplyUnapplyParametersContext);            end        else begin            Clear(ApplyUnapplyParameters);            GLSetup.GetRecordOnce();            if GLSetup."Journal Templ. Name Mandatory" then begin                GLSetup.TestField("Apply Jnl. Template Name");                GLSetup.TestField("Apply Jnl. Batch Name");                ApplyUnapplyParameters."Journal Template Name" := GLSetup."Apply Jnl. Template Name";                ApplyUnapplyParameters."Journal Batch Name" := GLSetup."Apply Jnl. Batch Name";                GenJnlBatch.Get(GLSetup."Apply Jnl. Template Name", GLSetup."Apply Jnl. Batch Name");            end;            ApplyUnapplyParameters."Document No." := Rec."Document No.";            Apply(Rec, ApplyUnapplyParameters);        end;    end;    var        GLSetup: Record "General Ledger Setup";        GenJnlBatch: Record "Gen. Journal Batch";        DetailedCustLedgEntryPreviewContext: Record "Detailed Cust. Ledg. Entry";        ApplyUnapplyParametersContext: Record "Apply Unapply Parameters";        RunOptionPreview: Option Apply,Unapply;        RunOptionPreviewContext: Option Apply,Unapply;        PreviewMode: Boolean;        PostingApplicationMsg: Label 'Posting application...';        MustNotBeBeforeErr: Label 'The posting date entered must not be before the posting date on the Cust. Ledger Entry.';        NoEntriesAppliedErr: Label 'Cannot post because you did not specify which entry to apply. You must specify an entry in the %1 field for one or more open entries.', Comment = '%1 - Caption of "Applies to ID" field of Gen. Journal Line';        UnapplyPostedAfterThisEntryErr: Label 'Before you can unapply this entry, you must first unapply all application entries that were posted after this entry.';#pragma warning disable AA0470        NoApplicationEntryErr: Label 'Cust. Ledger Entry No. %1 does not have an application entry.';#pragma warning restore AA0470        UnapplyingMsg: Label 'Unapplying and posting...';#pragma warning disable AA0470        UnapplyAllPostedAfterThisEntryErr: Label 'Before you can unapply this entry, you must first unapply all application entries in Cust. Ledger Entry No. %1 that were posted after this entry.';#pragma warning restore AA0470        NotAllowedPostingDatesErr: Label 'Posting date is not within the range of allowed posting dates.';#pragma warning disable AA0470        LatestEntryMustBeApplicationErr: Label 'The latest Transaction No. must be an application in Cust. Ledger Entry No. %1.';        CannotUnapplyExchRateErr: Label 'You cannot unapply the entry with the posting date %1, because the exchange rate for the additional reporting currency has been changed.';        CannotUnapplyInReversalErr: Label 'You cannot unapply Cust. Ledger Entry No. %1 because the entry is part of a reversal.';#pragma warning restore AA0470        CannotApplyClosedEntriesErr: Label 'One or more of the entries that you selected is closed. You cannot apply closed entries.';    /// <summary>    /// Applies the customer ledger entry based on the specified application parameters.    /// </summary>    /// <param name="CustLedgEntry">Specifies the customer ledger entry to apply.</param>    /// <param name="ApplyUnapplyParameters">Specifies the parameters for the application, including document number and posting date.</param>    /// <returns>True if the application was successful; otherwise, false.</returns>    procedure Apply(CustLedgEntry: Record "Cust. Ledger Entry"; ApplyUnapplyParameters: Record "Apply Unapply Parameters"): Boolean    var        PaymentToleranceMgt: Codeunit "Payment Tolerance Management";        IsHandled: Boolean;    begin        OnBeforeApply(CustLedgEntry, ApplyUnapplyParameters."Document No.", ApplyUnapplyParameters."Posting Date");        IsHandled := false;        OnApplyOnBeforePmtTolCust(CustLedgEntry, PaymentToleranceMgt, PreviewMode, IsHandled);        if not IsHandled then            if not PreviewMode then                if not PaymentToleranceMgt.PmtTolCust(CustLedgEntry) then                    exit(false);        CustLedgEntry.Get(CustLedgEntry."Entry No.");        if ApplyUnapplyParameters."Posting Date" = 0D then            ApplyUnapplyParameters."Posting Date" := GetApplicationDate(CustLedgEntry)        else            if ApplyUnapplyParameters."Posting Date" < GetApplicationDate(CustLedgEntry) then                Error(MustNotBeBeforeErr);        if ApplyUnapplyParameters."Document No." = '' then            ApplyUnapplyParameters."Document No." := CustLedgEntry."Document No.";        OnApplyOnBeforeCustPostApplyCustLedgEntry(CustLedgEntry, ApplyUnapplyParameters);        CustPostApplyCustLedgEntry(CustLedgEntry, ApplyUnapplyParameters);        exit(true);    end;    /// <summary>    /// Gets the latest posting date among all customer ledger entries with the same Applies-to ID.    /// </summary>    /// <param name="CustLedgEntry">Specifies the customer ledger entry used to find related entries by Applies-to ID.</param>    /// <returns>The latest posting date of the entries to be applied.</returns>    procedure GetApplicationDate(CustLedgEntry: Record "Cust. Ledger Entry") ApplicationDate: Date    var        ApplyToCustLedgEntry: Record "Cust. Ledger Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetApplicationDate(CustLedgEntry, ApplicationDate, IsHandled);        if IsHandled then            exit(ApplicationDate);        ApplicationDate := 0D;        ApplyToCustLedgEntry.SetCurrentKey("Customer No.", "Applies-to ID");        ApplyToCustLedgEntry.SetRange("Customer No.", CustLedgEntry."Customer No.");        ApplyToCustLedgEntry.SetRange("Applies-to ID", CustLedgEntry."Applies-to ID");        OnGetApplicationDateOnAfterSetFilters(ApplyToCustLedgEntry, CustLedgEntry);        ApplyToCustLedgEntry.FindSet();        repeat            if ApplyToCustLedgEntry."Posting Date" > ApplicationDate then                ApplicationDate := ApplyToCustLedgEntry."Posting Date";        until ApplyToCustLedgEntry.Next() = 0;    end;    local procedure CustPostApplyCustLedgEntry(CustLedgEntry: Record "Cust. Ledger Entry"; ApplyUnapplyParameters: Record "Apply Unapply Parameters")    var        SourceCodeSetup: Record "Source Code Setup";        GenJnlLine: Record "Gen. Journal Line";        GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line";        GenJnlPostPreview: Codeunit "Gen. Jnl.-Post Preview";        Window: Dialog;        EntryNoBeforeApplication: Integer;        EntryNoAfterApplication: Integer;        HideProgressWindow: Boolean;        SuppressCommit: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCustPostApplyCustLedgEntry(HideProgressWindow, CustLedgEntry, IsHandled);        if IsHandled then            exit;        if not HideProgressWindow then            Window.Open(PostingApplicationMsg);        SourceCodeSetup.Get();        GenJnlLine.Init();        GenJnlLine."Document No." := ApplyUnapplyParameters."Document No.";        GenJnlLine."Posting Date" := ApplyUnapplyParameters."Posting Date";        GenJnlLine."VAT Reporting Date" := GenJnlLine."Posting Date";        GenJnlLine."Document Date" := GenJnlLine."Posting Date";        GenJnlLine."Account Type" := GenJnlLine."Account Type"::Customer;        GenJnlLine."Account No." := CustLedgEntry."Customer No.";        CustLedgEntry.CalcFields("Debit Amount", "Credit Amount", "Debit Amount (LCY)", "Credit Amount (LCY)");        GenJnlLine.Correction :=            (CustLedgEntry."Debit Amount" < 0) or (CustLedgEntry."Credit Amount" < 0) or            (CustLedgEntry."Debit Amount (LCY)" < 0) or (CustLedgEntry."Credit Amount (LCY)" < 0);        GenJnlLine.CopyCustLedgEntry(CustLedgEntry);        GenJnlLine."Source Code" := SourceCodeSetup."Sales Entry Application";        GenJnlLine."System-Created Entry" := true;        GenJnlLine."Journal Template Name" := ApplyUnapplyParameters."Journal Template Name";        GenJnlLine."Journal Batch Name" := ApplyUnapplyParameters."Journal Batch Name";        EntryNoBeforeApplication := FindLastApplDtldCustLedgEntry();        OnBeforePostApplyCustLedgEntry(GenJnlLine, CustLedgEntry, GenJnlPostLine, ApplyUnapplyParameters);        GenJnlPostLine.CustPostApplyCustLedgEntry(GenJnlLine, CustLedgEntry);        OnAfterPostApplyCustLedgEntry(GenJnlLine, CustLedgEntry, GenJnlPostLine);        EntryNoAfterApplication := FindLastApplDtldCustLedgEntry();        if EntryNoAfterApplication = EntryNoBeforeApplication then            Error(NoEntriesAppliedErr, GenJnlLine.FieldCaption("Applies-to ID"));        if PreviewMode then            GenJnlPostPreview.ThrowError();        SuppressCommit := false;        OnCustPostApplyCustLedgEntryOnBeforeCommit(CustLedgEntry, SuppressCommit);        if not SuppressCommit then            Commit();        if not HideProgressWindow then            Window.Close();        RunUpdateAnalysisView();    end;    local procedure RunUpdateAnalysisView()    var        UpdateAnalysisView: Codeunit "Update Analysis View";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRunUpdateAnalysisView(IsHandled);        if IsHandled then            exit;        UpdateAnalysisView.UpdateAll(0, true);    end;    local procedure FindLastApplDtldCustLedgEntry(): Integer    var        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";    begin        DtldCustLedgEntry.LockTable();        exit(DtldCustLedgEntry.GetLastEntryNo());    end;    /// <summary>    /// Finds the last application entry number for the specified customer ledger entry.    /// </summary>    /// <param name="CustLedgEntryNo">Specifies the customer ledger entry number to search for applications.</param>    /// <returns>The entry number of the last application entry, or 0 if no application exists.</returns>    procedure FindLastApplEntry(CustLedgEntryNo: Integer): Integer    var        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        ApplicationEntryNo: Integer;    begin        DtldCustLedgEntry.SetCurrentKey("Cust. Ledger Entry No.", "Entry Type");        DtldCustLedgEntry.SetRange("Cust. Ledger Entry No.", CustLedgEntryNo);        DtldCustLedgEntry.SetRange("Entry Type", DtldCustLedgEntry."Entry Type"::Application);        DtldCustLedgEntry.SetRange(Unapplied, false);        OnFindLastApplEntryOnAfterSetFilters(DtldCustLedgEntry);        ApplicationEntryNo := 0;        if DtldCustLedgEntry.Find('-') then            repeat                if DtldCustLedgEntry."Entry No." > ApplicationEntryNo then                    ApplicationEntryNo := DtldCustLedgEntry."Entry No.";            until DtldCustLedgEntry.Next() = 0;        exit(ApplicationEntryNo);    end;    local procedure FindLastTransactionNo(CustLedgEntryNo: Integer): Integer    var        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        LastTransactionNo: Integer;    begin        DtldCustLedgEntry.SetCurrentKey("Cust. Ledger Entry No.", "Entry Type");        DtldCustLedgEntry.SetRange("Cust. Ledger Entry No.", CustLedgEntryNo);        DtldCustLedgEntry.SetRange(Unapplied, false);        DtldCustLedgEntry.SetFilter(            "Entry Type", '<>%1&<>%2',            DtldCustLedgEntry."Entry Type"::"Unrealized Loss", DtldCustLedgEntry."Entry Type"::"Unrealized Gain");        LastTransactionNo := 0;        if DtldCustLedgEntry.FindSet() then            repeat                if LastTransactionNo < DtldCustLedgEntry."Transaction No." then                    LastTransactionNo := DtldCustLedgEntry."Transaction No.";            until DtldCustLedgEntry.Next() = 0;        exit(LastTransactionNo);    end;    /// <summary>    /// Unapplies the specified detailed customer ledger entry if it is the last application entry.    /// </summary>    /// <param name="DtldCustLedgEntry">Specifies the detailed customer ledger entry to unapply.</param>    procedure UnApplyDtldCustLedgEntry(DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    var        ApplicationEntryNo: Integer;    begin        DtldCustLedgEntry.TestField("Entry Type", DtldCustLedgEntry."Entry Type"::Application);        DtldCustLedgEntry.TestField(Unapplied, false);        ApplicationEntryNo := FindLastApplEntry(DtldCustLedgEntry."Cust. Ledger Entry No.");        if DtldCustLedgEntry."Entry No." <> ApplicationEntryNo then            Error(UnapplyPostedAfterThisEntryErr);        CheckReversal(DtldCustLedgEntry."Cust. Ledger Entry No.");        UnApplyCustomer(DtldCustLedgEntry);    end;    /// <summary>    /// Validates that the customer ledger entry can be unapplied and retrieves the last application entry.    /// </summary>    /// <param name="CustLedgEntryNo">Specifies the customer ledger entry number to check.</param>    /// <param name="DetailedCustLedgEntry">Returns the detailed customer ledger entry containing the last application.</param>    procedure CheckCustLedgEntryToUnapply(CustLedgEntryNo: Integer; var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    var        ApplicationEntryNo: Integer;    begin        CheckReversal(CustLedgEntryNo);        ApplicationEntryNo := FindLastApplEntry(CustLedgEntryNo);        if ApplicationEntryNo = 0 then            Error(NoApplicationEntryErr, CustLedgEntryNo);        DetailedCustLedgEntry.Get(ApplicationEntryNo);    end;    /// <summary>    /// Unapplies the customer ledger entry by its entry number.    /// </summary>    /// <param name="CustLedgEntryNo">Specifies the entry number of the customer ledger entry to unapply.</param>    procedure UnApplyCustLedgEntry(CustLedgEntryNo: Integer)    var        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";    begin        CheckCustLedgEntryToUnapply(CustLedgEntryNo, DtldCustLedgEntry);        UnApplyCustomer(DtldCustLedgEntry);    end;    local procedure UnApplyCustomer(DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    var        UnapplyCustEntries: Page "Unapply Customer Entries";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUnApplyCustomer(DtldCustLedgEntry, IsHandled);        if IsHandled then            exit;        DtldCustLedgEntry.TestField("Entry Type", DtldCustLedgEntry."Entry Type"::Application);        DtldCustLedgEntry.TestField(Unapplied, false);        UnapplyCustEntries.SetDtldCustLedgEntry(DtldCustLedgEntry."Entry No.");        UnapplyCustEntries.LookupMode(true);        UnapplyCustEntries.RunModal();        OnAfterUnApplyCustomer(DtldCustLedgEntry);    end;    /// <summary>    /// Posts the unapplication of a customer ledger entry with automatic commit.    /// </summary>    /// <param name="DtldCustLedgEntry2">Specifies the detailed customer ledger entry to unapply.</param>    /// <param name="ApplyUnapplyParameters">Specifies the parameters for the unapplication, including document number and posting date.</param>    procedure PostUnApplyCustomer(DtldCustLedgEntry2: Record "Detailed Cust. Ledg. Entry"; ApplyUnapplyParameters: Record "Apply Unapply Parameters")    begin        PostUnApplyCustomerCommit(DtldCustLedgEntry2, ApplyUnapplyParameters, true);    end;    /// <summary>    /// Posts the unapplication of a customer ledger entry with optional commit control.    /// </summary>    /// <param name="DtldCustLedgEntry2">Specifies the detailed customer ledger entry to unapply.</param>    /// <param name="ApplyUnapplyParameters">Specifies the parameters for the unapplication, including document number and posting date.</param>    /// <param name="CommitChanges">Specifies whether to commit changes after posting the unapplication.</param>    procedure PostUnApplyCustomerCommit(DtldCustLedgEntry2: Record "Detailed Cust. Ledg. Entry"; ApplyUnapplyParameters: Record "Apply Unapply Parameters"; CommitChanges: Boolean)    var        GLEntry: Record "G/L Entry";        CustLedgEntry: Record "Cust. Ledger Entry";        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        SourceCodeSetup: Record "Source Code Setup";        GenJnlLine: Record "Gen. Journal Line";        DateComprReg: Record "Date Compr. Register";        TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary;        GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line";        GenJnlPostPreview: Codeunit "Gen. Jnl.-Post Preview";        Window: Dialog;        AddCurrChecked: Boolean;        MaxPostingDate: Date;        HideProgressWindow: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostUnApplyCustomerCommit(            HideProgressWindow, PreviewMode, DtldCustLedgEntry2, ApplyUnapplyParameters."Document No.", ApplyUnapplyParameters."Posting Date",            CommitChanges, IsHandled);        if IsHandled then            exit;        MaxPostingDate := 0D;        GLEntry.LockTable();        DtldCustLedgEntry.LockTable();        CustLedgEntry.LockTable();        CustLedgEntry.Get(DtldCustLedgEntry2."Cust. Ledger Entry No.");        OnPostUnApplyCustomerCommitOnAfterGetCustLedgEntry(CustLedgEntry);        if GenJnlBatch.Get(CustLedgEntry."Journal Templ. Name", CustLedgEntry."Journal Batch Name") then;        CheckPostingDate(ApplyUnapplyParameters, MaxPostingDate);        if ApplyUnapplyParameters."Posting Date" < DtldCustLedgEntry2."Posting Date" then            Error(MustNotBeBeforeErr);        OnPostUnApplyCustomerCommitOnBeforeFilterDtldCustLedgEntry(DtldCustLedgEntry2, ApplyUnapplyParameters);        if DtldCustLedgEntry2."Transaction No." = 0 then begin            DtldCustLedgEntry.SetCurrentKey("Application No.", "Customer No.", "Entry Type");            DtldCustLedgEntry.SetRange("Application No.", DtldCustLedgEntry2."Application No.");        end else begin            DtldCustLedgEntry.SetCurrentKey("Transaction No.", "Customer No.", "Entry Type");            DtldCustLedgEntry.SetRange("Transaction No.", DtldCustLedgEntry2."Transaction No.");        end;        DtldCustLedgEntry.SetRange("Customer No.", DtldCustLedgEntry2."Customer No.");        DtldCustLedgEntry.SetFilter("Entry Type", '<>%1', DtldCustLedgEntry."Entry Type"::"Initial Entry");        DtldCustLedgEntry.SetRange(Unapplied, false);        OnPostUnApplyCustomerCommitOnAfterSetFilters(DtldCustLedgEntry, DtldCustLedgEntry2);        if DtldCustLedgEntry.Find('-') then            repeat                if not AddCurrChecked then begin                    CheckAdditionalCurrency(ApplyUnapplyParameters."Posting Date", DtldCustLedgEntry."Posting Date");                    AddCurrChecked := true;                end;                CheckReversal(DtldCustLedgEntry."Cust. Ledger Entry No.");                if DtldCustLedgEntry."Transaction No." <> 0 then                    CheckUnappliedEntries(DtldCustLedgEntry);            until DtldCustLedgEntry.Next() = 0;        DateComprReg.CheckMaxDateCompressed(MaxPostingDate, 0);        GLSetup.GetRecordOnce();        SourceCodeSetup.Get();        CustLedgEntry.Get(DtldCustLedgEntry2."Cust. Ledger Entry No.");        GenJnlLine."Document No." := ApplyUnapplyParameters."Document No.";        GenJnlLine."Posting Date" := ApplyUnapplyParameters."Posting Date";        GenJnlLine."VAT Reporting Date" := GenJnlLine."Posting Date";        GenJnlLine."Account Type" := GenJnlLine."Account Type"::Customer;        GenJnlLine."Account No." := DtldCustLedgEntry2."Customer No.";        GenJnlLine.Correction := true;        GenJnlLine.CopyCustLedgEntry(CustLedgEntry);        GenJnlLine."Source Code" := SourceCodeSetup."Unapplied Sales Entry Appln.";        GenJnlLine."Source Currency Code" := DtldCustLedgEntry2."Currency Code";        GenJnlLine."System-Created Entry" := true;        if GLSetup."Journal Templ. Name Mandatory" then begin            GenJnlLine."Journal Template Name" := GLSetup."Apply Jnl. Template Name";            GenJnlLine."Journal Batch Name" := GLSetup."Apply Jnl. Batch Name";        end;        if not HideProgressWindow then            Window.Open(UnapplyingMsg);        OnBeforePostUnapplyCustLedgEntry(GenJnlLine, CustLedgEntry, DtldCustLedgEntry2, GenJnlPostLine, ApplyUnapplyParameters);        CollectAffectedLedgerEntries(TempCustLedgerEntry, DtldCustLedgEntry2);        GenJnlPostLine.UnapplyCustLedgEntry(GenJnlLine, DtldCustLedgEntry2);        RunCustExchRateAdjustment(GenJnlLine, TempCustLedgerEntry);        OnAfterPostUnapplyCustLedgEntry(            GenJnlLine, CustLedgEntry, DtldCustLedgEntry2, GenJnlPostLine, CommitChanges, TempCustLedgerEntry);        if PreviewMode then            GenJnlPostPreview.ThrowError();        OnPostUnApplyCustomerCommitOnAfterPreviewMode(CustLedgEntry);        if CommitChanges then            Commit();        if not HideProgressWindow then            Window.Close();    end;    local procedure RunCustExchRateAdjustment(var GenJnlLine: Record "Gen. Journal Line"; var TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary)    var        ExchRateAdjmtRunHandler: Codeunit "Exch. Rate Adjmt. Run Handler";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRunCustExchRateAdjustment(GenJnlLine, TempCustLedgerEntry, IsHandled);        if IsHandled then            exit;        ExchRateAdjmtRunHandler.RunCustExchRateAdjustment(GenJnlLine, TempCustLedgerEntry);    end;    local procedure CheckPostingDate(ApplyUnapplyParameters: Record "Apply Unapply Parameters"; var MaxPostingDate: Date)    var        GenJnlCheckLine: Codeunit "Gen. Jnl.-Check Line";    begin        GenJnlCheckLine.SetGenJnlBatch(GenJnlBatch);        if GenJnlCheckLine.DateNotAllowed(ApplyUnapplyParameters."Posting Date") then            Error(NotAllowedPostingDatesErr);        if ApplyUnapplyParameters."Posting Date" > MaxPostingDate then            MaxPostingDate := ApplyUnapplyParameters."Posting Date";    end;    local procedure CheckAdditionalCurrency(OldPostingDate: Date; NewPostingDate: Date)    var        CurrExchRate: Record "Currency Exchange Rate";    begin        if OldPostingDate = NewPostingDate then            exit;        GLSetup.GetRecordOnce();        if GLSetup."Additional Reporting Currency" <> '' then            if CurrExchRate.ExchangeRate(OldPostingDate, GLSetup."Additional Reporting Currency") <>               CurrExchRate.ExchangeRate(NewPostingDate, GLSetup."Additional Reporting Currency")            then                Error(CannotUnapplyExchRateErr, NewPostingDate);    end;    /// <summary>    /// Checks whether the customer ledger entry is part of a reversal and raises an error if it is.    /// </summary>    /// <param name="CustLedgEntryNo">Specifies the customer ledger entry number to check for reversal status.</param>    procedure CheckReversal(CustLedgEntryNo: Integer)    var        CustLedgEntry: Record "Cust. Ledger Entry";    begin        CustLedgEntry.Get(CustLedgEntryNo);        if CustLedgEntry.Reversed then            Error(CannotUnapplyInReversalErr, CustLedgEntryNo);        OnAfterCheckReversal(CustLedgEntry);    end;    /// <summary>    /// Opens the Apply Customer Entries page to allow the user to select entries for application.    /// </summary>    /// <param name="ApplyingCustLedgEntry">Specifies the customer ledger entry that is being applied to other entries.</param>    procedure ApplyCustEntryFormEntry(var ApplyingCustLedgEntry: Record "Cust. Ledger Entry")    var        CustLedgEntry: Record "Cust. Ledger Entry";        CustEntryApplID: Code[50];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeApplyCustEntryFormEntry(ApplyingCustLedgEntry, IsHandled);        if IsHandled then            exit;        if not ApplyingCustLedgEntry.Open then            Error(CannotApplyClosedEntriesErr);        OnApplyCustEntryFormEntryOnAfterCheckEntryOpen(ApplyingCustLedgEntry);        CustEntryApplID := UserId;        if CustEntryApplID = '' then            CustEntryApplID := '***';        if ApplyingCustLedgEntry."Remaining Amount" = 0 then            ApplyingCustLedgEntry.CalcFields("Remaining Amount");        ApplyingCustLedgEntry."Applying Entry" := true;        if ApplyingCustLedgEntry."Applies-to ID" = '' then            ApplyingCustLedgEntry."Applies-to ID" := CustEntryApplID;        ApplyingCustLedgEntry."Amount to Apply" := ApplyingCustLedgEntry."Remaining Amount";        OnApplyCustEntryFormEntryOnBeforeRunCustEntryEdit(ApplyingCustLedgEntry);        CODEUNIT.Run(CODEUNIT::"Cust. Entry-Edit", ApplyingCustLedgEntry);        Commit();        CustLedgEntry.SetCurrentKey("Customer No.", Open, Positive);        CustLedgEntry.SetRange("Customer No.", ApplyingCustLedgEntry."Customer No.");        CustLedgEntry.SetRange(Open, true);        RunApplyCustEntries(CustLedgEntry, ApplyingCustLedgEntry, CustEntryApplID);    end;    local procedure RunApplyCustEntries(var CustLedgEntry: Record "Cust. Ledger Entry"; var ApplyingCustLedgEntry: Record "Cust. Ledger Entry"; CustEntryApplID: Code[50])    var        ApplyCustEntries: Page "Apply Customer Entries";        IsHandled: Boolean;    begin        IsHandled := false;        OnApplyApplyCustEntryFormEntryOnAfterCustLedgEntrySetFilters(CustLedgEntry, ApplyingCustLedgEntry, IsHandled, CustEntryApplID);        if IsHandled then            exit;        if CustLedgEntry.FindFirst() then begin            ApplyCustEntries.SetCustLedgEntry(ApplyingCustLedgEntry);            ApplyCustEntries.SetRecord(CustLedgEntry);            ApplyCustEntries.SetTableView(CustLedgEntry);            if ApplyingCustLedgEntry."Applies-to ID" <> CustEntryApplID then                ApplyCustEntries.SetAppliesToID(ApplyingCustLedgEntry."Applies-to ID");            ApplyCustEntries.RunModal();            Clear(ApplyCustEntries);            ApplyingCustLedgEntry."Applying Entry" := false;            ApplyingCustLedgEntry."Applies-to ID" := '';            ApplyingCustLedgEntry."Amount to Apply" := 0;        end;    end;    local procedure CollectAffectedLedgerEntries(var TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary; DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry")    var        DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry";    begin        TempCustLedgerEntry.DeleteAll();        if DetailedCustLedgEntry2."Transaction No." = 0 then begin            DetailedCustLedgEntry.SetCurrentKey("Application No.", "Customer No.", "Entry Type");            DetailedCustLedgEntry.SetRange("Application No.", DetailedCustLedgEntry2."Application No.");        end else begin            DetailedCustLedgEntry.SetCurrentKey("Transaction No.", "Customer No.", "Entry Type");            DetailedCustLedgEntry.SetRange("Transaction No.", DetailedCustLedgEntry2."Transaction No.");        end;        DetailedCustLedgEntry.SetRange("Customer No.", DetailedCustLedgEntry2."Customer No.");        DetailedCustLedgEntry.SetFilter("Entry Type", '<>%1', DetailedCustLedgEntry."Entry Type"::"Initial Entry");        DetailedCustLedgEntry.SetRange(Unapplied, false);        OnCollectAffectedLedgerEntriesOnAfterSetFilters(DetailedCustLedgEntry, DetailedCustLedgEntry2);        if DetailedCustLedgEntry.FindSet() then            repeat                TempCustLedgerEntry."Entry No." := DetailedCustLedgEntry."Cust. Ledger Entry No.";                if TempCustLedgerEntry.Insert() then;            until DetailedCustLedgEntry.Next() = 0;    end;    local procedure FindLastApplTransactionEntry(CustLedgEntryNo: Integer): Integer    var        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        LastTransactionNo: Integer;    begin        DtldCustLedgEntry.SetCurrentKey("Cust. Ledger Entry No.", "Entry Type");        DtldCustLedgEntry.SetRange("Cust. Ledger Entry No.", CustLedgEntryNo);        DtldCustLedgEntry.SetRange("Entry Type", DtldCustLedgEntry."Entry Type"::Application);        LastTransactionNo := 0;        if DtldCustLedgEntry.Find('-') then            repeat                if (DtldCustLedgEntry."Transaction No." > LastTransactionNo) and not DtldCustLedgEntry.Unapplied then                    LastTransactionNo := DtldCustLedgEntry."Transaction No.";            until DtldCustLedgEntry.Next() = 0;        exit(LastTransactionNo);    end;    /// <summary>    /// Previews the application of a customer ledger entry without posting.    /// </summary>    /// <param name="CustLedgEntry">Specifies the customer ledger entry to preview the application for.</param>    /// <param name="ApplyUnapplyParameters">Specifies the parameters for the application preview, including document number and posting date.</param>    procedure PreviewApply(CustLedgEntry: Record "Cust. Ledger Entry"; ApplyUnapplyParameters: Record "Apply Unapply Parameters")    var        GenJnlPostPreview: Codeunit "Gen. Jnl.-Post Preview";        CustEntryApplyPostedEntries: Codeunit "CustEntry-Apply Posted Entries";        PaymentToleranceMgt: Codeunit "Payment Tolerance Management";    begin        if not PaymentToleranceMgt.PmtTolCust(CustLedgEntry) then            exit;        BindSubscription(CustEntryApplyPostedEntries);        CustEntryApplyPostedEntries.SetApplyContext(ApplyUnapplyParameters);        GenJnlPostPreview.Preview(CustEntryApplyPostedEntries, CustLedgEntry);    end;    /// <summary>    /// Previews the unapplication of a detailed customer ledger entry without posting.    /// </summary>    /// <param name="DetailedCustLedgEntry">Specifies the detailed customer ledger entry to preview the unapplication for.</param>    /// <param name="ApplyUnapplyParameters">Specifies the parameters for the unapplication preview, including document number and posting date.</param>    procedure PreviewUnapply(DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; ApplyUnapplyParameters: Record "Apply Unapply Parameters")    var        CustLedgEntry: Record "Cust. Ledger Entry";        GenJnlPostPreview: Codeunit "Gen. Jnl.-Post Preview";        CustEntryApplyPostedEntries: Codeunit "CustEntry-Apply Posted Entries";    begin        BindSubscription(CustEntryApplyPostedEntries);        CustEntryApplyPostedEntries.SetUnapplyContext(DetailedCustLedgEntry, ApplyUnapplyParameters);        GenJnlPostPreview.Preview(CustEntryApplyPostedEntries, CustLedgEntry);    end;    /// <summary>    /// Sets the context for an application preview operation.    /// </summary>    /// <param name="ApplyUnapplyParameters">Specifies the parameters to use for the application preview.</param>    procedure SetApplyContext(ApplyUnapplyParameters: Record "Apply Unapply Parameters")    begin        ApplyUnapplyParametersContext := ApplyUnapplyParameters;        RunOptionPreviewContext := RunOptionPreview::Apply;    end;    /// <summary>    /// Sets the context for an unapplication preview operation.    /// </summary>    /// <param name="DetailedCustLedgEntry">Specifies the detailed customer ledger entry for the unapplication preview.</param>    /// <param name="ApplyUnapplyParameters">Specifies the parameters to use for the unapplication preview.</param>    procedure SetUnapplyContext(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; ApplyUnapplyParameters: Record "Apply Unapply Parameters")    begin        ApplyUnapplyParametersContext := ApplyUnapplyParameters;        DetailedCustLedgEntryPreviewContext := DetailedCustLedgEntry;        RunOptionPreviewContext := RunOptionPreview::Unapply;    end;    /// <summary>    /// Retrieves all customer ledger entries that have been applied to the specified entry.    /// </summary>    /// <param name="TempAppliedCustLedgerEntry">Returns a temporary table containing the applied customer ledger entries.</param>    /// <param name="CustLedgerEntryNo">Specifies the customer ledger entry number to find applied entries for.</param>    procedure GetAppliedCustLedgerEntries(var TempAppliedCustLedgerEntry: Record "Cust. Ledger Entry" temporary; CustLedgerEntryNo: Integer)    var        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        ApplnDtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        CustLedgerEntry: Record "Cust. Ledger Entry";    begin        DtldCustLedgEntry.SetCurrentKey("Cust. Ledger Entry No.");        DtldCustLedgEntry.SetRange("Cust. Ledger Entry No.", CustLedgerEntryNo);        DtldCustLedgEntry.SetFilter("Applied Cust. Ledger Entry No.", '<>%1', 0);        DtldCustLedgEntry.SetRange(Unapplied, false);        if DtldCustLedgEntry.FindSet() then            repeat                if DtldCustLedgEntry."Cust. Ledger Entry No." =                   DtldCustLedgEntry."Applied Cust. Ledger Entry No."                then begin                    ApplnDtldCustLedgEntry.SetCurrentKey("Applied Cust. Ledger Entry No.", "Entry Type");                    ApplnDtldCustLedgEntry.SetRange(                        "Applied Cust. Ledger Entry No.", DtldCustLedgEntry."Applied Cust. Ledger Entry No.");                    ApplnDtldCustLedgEntry.SetRange("Entry Type", ApplnDtldCustLedgEntry."Entry Type"::Application);                    ApplnDtldCustLedgEntry.SetRange(Unapplied, false);                    if ApplnDtldCustLedgEntry.FindSet() then                        repeat                            if ApplnDtldCustLedgEntry."Cust. Ledger Entry No." <>                               ApplnDtldCustLedgEntry."Applied Cust. Ledger Entry No."                            then                                if CustLedgerEntry.Get(ApplnDtldCustLedgEntry."Cust. Ledger Entry No.") then begin                                    TempAppliedCustLedgerEntry := CustLedgerEntry;                                    if TempAppliedCustLedgerEntry.Insert(false) then;                                end;                        until ApplnDtldCustLedgEntry.Next() = 0;                end else                    if CustLedgerEntry.Get(DtldCustLedgEntry."Applied Cust. Ledger Entry No.") then begin                        TempAppliedCustLedgerEntry := CustLedgerEntry;                        if TempAppliedCustLedgerEntry.Insert(false) then;                    end;            until DtldCustLedgEntry.Next() = 0;    end;    local procedure CheckUnappliedEntries(DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    var        LastTransactionNo: Integer;        IsHandled: Boolean;    begin        if DtldCustLedgEntry."Entry Type" = DtldCustLedgEntry."Entry Type"::Application then begin            LastTransactionNo := FindLastApplTransactionEntry(DtldCustLedgEntry."Cust. Ledger Entry No.");            IsHandled := false;            OnCheckUnappliedEntriesOnBeforeUnapplyAllEntriesError(DtldCustLedgEntry, LastTransactionNo, IsHandled);            if not IsHandled then                if (LastTransactionNo <> 0) and (LastTransactionNo <> DtldCustLedgEntry."Transaction No.") then                    Error(UnapplyAllPostedAfterThisEntryErr, DtldCustLedgEntry."Cust. Ledger Entry No.");        end;        LastTransactionNo := FindLastTransactionNo(DtldCustLedgEntry."Cust. Ledger Entry No.");        if (LastTransactionNo <> 0) and (LastTransactionNo <> DtldCustLedgEntry."Transaction No.") then            Error(LatestEntryMustBeApplicationErr, DtldCustLedgEntry."Cust. Ledger Entry No.");    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Gen. Jnl.-Post Preview", 'OnRunPreview', '', false, false)]    local procedure OnRunPreview(var Result: Boolean; Subscriber: Variant; RecVar: Variant)    var        CustEntryApplyPostedEntries: Codeunit "CustEntry-Apply Posted Entries";    begin        CustEntryApplyPostedEntries := Subscriber;        PreviewMode := true;        Result := CustEntryApplyPostedEntries.Run(RecVar);    end;    /// <summary>    /// Raised after checking if a customer ledger entry is part of a reversal.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry that was checked.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckReversal(CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Raised after posting the application of a customer ledger entry.    /// </summary>    /// <param name="GenJournalLine">The general journal line used for posting.</param>    /// <param name="CustLedgerEntry">The customer ledger entry that was applied.</param>    /// <param name="GenJnlPostLine">The posting codeunit instance.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostApplyCustLedgEntry(GenJournalLine: Record "Gen. Journal Line"; CustLedgerEntry: Record "Cust. Ledger Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")    begin    end;    /// <summary>    /// Raised after posting the unapplication of a customer ledger entry.    /// </summary>    /// <param name="GenJournalLine">The general journal line used for posting.</param>    /// <param name="CustLedgerEntry">The customer ledger entry that was unapplied.</param>    /// <param name="DetailedCustLedgEntry">The detailed customer ledger entry that was unapplied.</param>    /// <param name="GenJnlPostLine">The posting codeunit instance.</param>    /// <param name="CommitChanges">Indicates whether changes should be committed.</param>    /// <param name="TempCustLedgerEntry">Temporary table containing affected ledger entries.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterPostUnapplyCustLedgEntry(GenJournalLine: Record "Gen. Journal Line"; CustLedgerEntry: Record "Cust. Ledger Entry"; DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var CommitChanges: Boolean; var TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary)    begin    end;    /// <summary>    /// Raised after unapplying a customer ledger entry through the UI.    /// </summary>    /// <param name="DtldCustLedgEntry">The detailed customer ledger entry that was unapplied.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUnApplyCustomer(DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry");    begin    end;    /// <summary>    /// Raised after checking that the entry is open in the apply customer entry form.    /// </summary>    /// <param name="ApplyingCustLedgEntry">The applying customer ledger entry.</param>    [IntegrationEvent(false, false)]    local procedure OnApplyCustEntryFormEntryOnAfterCheckEntryOpen(ApplyingCustLedgEntry: Record "Cust. Ledger Entry");    begin    end;    /// <summary>    /// Raised before running customer entry edit in the apply customer entry form.    /// </summary>    /// <param name="ApplyingCustLedgEntry">The applying customer ledger entry.</param>    [IntegrationEvent(false, false)]    local procedure OnApplyCustEntryFormEntryOnBeforeRunCustEntryEdit(var ApplyingCustLedgEntry: Record "Cust. Ledger Entry");    begin    end;    /// <summary>    /// Raised after filters have been set on customer ledger entries in the apply form.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry with filters applied.</param>    /// <param name="ApplyingCustLedgerEntry">The applying customer ledger entry.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    /// <param name="CustEntryApplID">The application ID.</param>    [IntegrationEvent(false, false)]    local procedure OnApplyApplyCustEntryFormEntryOnAfterCustLedgEntrySetFilters(var CustLedgerEntry: Record "Cust. Ledger Entry"; var ApplyingCustLedgerEntry: Record "Cust. Ledger Entry" temporary; var IsHandled: Boolean; var CustEntryApplID: Code[50]);    begin    end;    /// <summary>    /// Raised before applying a customer ledger entry.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry to apply.</param>    /// <param name="DocumentNo">The document number for the application.</param>    /// <param name="ApplicationDate">The application date.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeApply(var CustLedgerEntry: Record "Cust. Ledger Entry"; var DocumentNo: Code[20]; var ApplicationDate: Date)    begin    end;    /// <summary>    /// Raised before opening the apply customer entry form.    /// </summary>    /// <param name="ApplyingCustLedgEntry">The applying customer ledger entry.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeApplyCustEntryFormEntry(var ApplyingCustLedgEntry: Record "Cust. Ledger Entry"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before getting the application date.    /// </summary>    /// <param name="CustLedgEntry">The customer ledger entry.</param>    /// <param name="ApplicationDate">The application date to return.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetApplicationDate(CustLedgEntry: Record "Cust. Ledger Entry"; var ApplicationDate: Date; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before posting the application of a customer ledger entry.    /// </summary>    /// <param name="GenJournalLine">The general journal line for posting.</param>    /// <param name="CustLedgerEntry">The customer ledger entry to apply.</param>    /// <param name="GenJnlPostLine">The posting codeunit instance.</param>    /// <param name="ApplyUnapplyParameters">The application parameters.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostApplyCustLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; CustLedgerEntry: Record "Cust. Ledger Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; ApplyUnapplyParameters: Record "Apply Unapply Parameters")    begin    end;    /// <summary>    /// Raised before posting the unapplication of a customer ledger entry.    /// </summary>    /// <param name="GenJournalLine">The general journal line for posting.</param>    /// <param name="CustLedgerEntry">The customer ledger entry to unapply.</param>    /// <param name="DetailedCustLedgEntry">The detailed customer ledger entry to unapply.</param>    /// <param name="GenJnlPostLine">The posting codeunit instance.</param>    /// <param name="ApplyUnapplyParameters">The unapplication parameters.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostUnapplyCustLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; CustLedgerEntry: Record "Cust. Ledger Entry"; DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; ApplyUnapplyParameters: Record "Apply Unapply Parameters")    begin    end;    /// <summary>    /// Raised after filters have been set when collecting affected ledger entries.    /// </summary>    /// <param name="DetailedCustLedgEntry">The detailed customer ledger entry with filters.</param>    /// <param name="DetailedCustLedgEntry2">The original detailed customer ledger entry.</param>    [IntegrationEvent(false, false)]    local procedure OnCollectAffectedLedgerEntriesOnAfterSetFilters(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry")    begin    end;    /// <summary>    /// Raised after filters have been set when finding the last application entry.    /// </summary>    /// <param name="DetailedCustLedgEntry">The detailed customer ledger entry with filters.</param>    [IntegrationEvent(false, false)]    local procedure OnFindLastApplEntryOnAfterSetFilters(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    begin    end;    /// <summary>    /// Raised before posting the customer application.    /// </summary>    /// <param name="HideProgressWindow">Set to true to hide the progress window.</param>    /// <param name="CustLedgEntry">The customer ledger entry to apply.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCustPostApplyCustLedgEntry(var HideProgressWindow: Boolean; CustLedgEntry: Record "Cust. Ledger Entry"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised after filters have been set when getting the application date.    /// </summary>    /// <param name="ApplyToCustLedgEntry">The apply-to customer ledger entry with filters.</param>    /// <param name="CustLedgEntry">The original customer ledger entry.</param>    [IntegrationEvent(false, false)]    local procedure OnGetApplicationDateOnAfterSetFilters(var ApplyToCustLedgEntry: Record "Cust. Ledger Entry"; CustLedgEntry: Record "Cust. Ledger Entry");    begin    end;    /// <summary>    /// Raised before running the update analysis view.    /// </summary>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeRunUpdateAnalysisView(var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before running the customer exchange rate adjustment.    /// </summary>    /// <param name="GenJnlLine">The general journal line.</param>    /// <param name="TempCustLedgerEntry">Temporary table of affected customer ledger entries.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeRunCustExchRateAdjustment(var GenJnlLine: Record "Gen. Journal Line"; var TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before posting the unapplication with commit control.    /// </summary>    /// <param name="HideProgressWindow">Set to true to hide the progress window.</param>    /// <param name="PreviewMode">Indicates whether in preview mode.</param>    /// <param name="DetailedCustLedgEntry2">The detailed customer ledger entry to unapply.</param>    /// <param name="DocNo">The document number.</param>    /// <param name="PostingDate">The posting date.</param>    /// <param name="CommitChanges">Indicates whether to commit changes.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostUnApplyCustomerCommit(var HideProgressWindow: Boolean; PreviewMode: Boolean; DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry"; DocNo: Code[20]; PostingDate: Date; CommitChanges: Boolean; var IsHandled: Boolean);    begin    end;    /// <summary>    /// Raised before raising the unapply all entries error.    /// </summary>    /// <param name="DtldCustLedgEntry">The detailed customer ledger entry being checked.</param>    /// <param name="LastTransactionNo">The last transaction number found.</param>    /// <param name="IsHandled">Set to true to skip the error.</param>    [IntegrationEvent(false, false)]    local procedure OnCheckUnappliedEntriesOnBeforeUnapplyAllEntriesError(DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; LastTransactionNo: Integer; var IsHandled: Boolean);    begin    end;    /// <summary>    /// Raised before committing the customer application posting.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry that was applied.</param>    /// <param name="SuppressCommit">Set to true to suppress the commit.</param>    [IntegrationEvent(false, false)]    local procedure OnCustPostApplyCustLedgEntryOnBeforeCommit(var CustLedgerEntry: Record "Cust. Ledger Entry"; var SuppressCommit: Boolean);    begin    end;    /// <summary>    /// Raised before unapplying a customer entry through the UI.    /// </summary>    /// <param name="DtldCustLedgEntry">The detailed customer ledger entry to unapply.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUnApplyCustomer(DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var IsHandled: Boolean);    begin    end;    /// <summary>    /// Raised after filters have been set during unapplication posting.    /// </summary>    /// <param name="DetailedCustLedgEntry">The detailed customer ledger entry with filters.</param>    /// <param name="DetailedCustLedgEntry2">The original detailed customer ledger entry.</param>    [IntegrationEvent(false, false)]    local procedure OnPostUnApplyCustomerCommitOnAfterSetFilters(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry")    begin    end;    /// <summary>    /// Raised after getting the customer ledger entry during unapplication.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry retrieved.</param>    [IntegrationEvent(false, false)]    local procedure OnPostUnApplyCustomerCommitOnAfterGetCustLedgEntry(var CustLedgerEntry: Record "Cust. Ledger Entry");    begin    end;    /// <summary>    /// Raised before processing payment tolerance during application.    /// </summary>    /// <param name="CustLedgEntry">The customer ledger entry.</param>    /// <param name="PaymentToleranceMgt">The payment tolerance management codeunit.</param>    /// <param name="PreviewMode">Indicates whether in preview mode.</param>    /// <param name="IsHandled">Set to true to skip default processing.</param>    [IntegrationEvent(false, false)]    local procedure OnApplyOnBeforePmtTolCust(CustLedgEntry: Record "Cust. Ledger Entry"; var PaymentToleranceMgt: Codeunit "Payment Tolerance Management"; PreviewMode: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Raised before posting the customer ledger entry application.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry to apply.</param>    /// <param name="ApplyUnapplyParameters">The application parameters.</param>    [IntegrationEvent(false, false)]    local procedure OnApplyOnBeforeCustPostApplyCustLedgEntry(CustLedgerEntry: Record "Cust. Ledger Entry"; var ApplyUnapplyParameters: Record "Apply Unapply Parameters")    begin    end;    /// <summary>    /// Raised before filtering detailed customer ledger entries during unapplication.    /// </summary>    /// <param name="DetailedCustLedgEntry2">The detailed customer ledger entry to unapply.</param>    /// <param name="ApplyUnapplyParameters">The unapplication parameters.</param>    [IntegrationEvent(false, false)]    local procedure OnPostUnApplyCustomerCommitOnBeforeFilterDtldCustLedgEntry(DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry"; ApplyUnapplyParameters: Record "Apply Unapply Parameters")    begin    end;    /// <summary>    /// Raised after preview mode processing during unapplication.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry.</param>    [IntegrationEvent(false, false)]    local procedure OnPostUnApplyCustomerCommitOnAfterPreviewMode(CustLedgerEntry: Record "Cust. Ledger Entry");    begin    end;}