Codeunit 370 Bank Acc. Reconciliation Post

Base Application, Microsoft.Bank.Reconciliation

src/Layers/W1/BaseApp/Bank/Reconciliation/BankAccReconciliationPost.Codeunit.al1,276 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.Bank.Reconciliation;using Microsoft.Bank.BankAccount;using Microsoft.Bank.Check;using Microsoft.Bank.Ledger;using Microsoft.Bank.Statement;using Microsoft.Finance.Analysis;using Microsoft.Finance.Currency;using Microsoft.Finance.Dimension;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Posting;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Foundation.AuditCodes;using Microsoft.HumanResources.Payables;using Microsoft.Purchases.Payables;using Microsoft.Sales.Receivables;using System.Reflection;using System.Telemetry;using System.Utilities;/// <summary>/// Handles the posting process for bank account reconciliation and payment application documents./// This codeunit processes completed reconciliation statements, creating permanent ledger entries,/// applying payments to customer and vendor accounts, and finalizing bank reconciliation transactions./// Supports both bank reconciliation and payment application workflows with comprehensive validation,/// posting preview, and audit trail generation./// </summary>/// <remarks>/// Key features include posting validation, applied payment entries creation, bank ledger entry updates,/// check ledger entry processing, dimension posting, and integration with general journal posting engine./// Provides posting preview capability for validation before final commitment and comprehensive error handling/// for application discrepancies, tolerance violations, and incomplete reconciliations./// Integration events enable customization of posting logic, validation rules, and posting procedures./// </remarks>codeunit 370 "Bank Acc. Reconciliation Post"{    Permissions = TableData "Bank Account Ledger Entry" = rm,                  TableData "Check Ledger Entry" = rm,                  TableData "Bank Account" = rm,                  TableData "Bank Account Statement" = ri,                  TableData "Bank Account Statement Line" = ri,                  TableData "Posted Payment Recon. Hdr" = ri;    TableNo = "Bank Acc. Reconciliation";    trigger OnRun()    begin        if GuiAllowed and not PreviewMode then begin            Window.Open('#1#################################\\' + PostingLinesTxt);            Window.Update(1, StrSubstNo('%1 %2', Rec."Bank Account No.", Rec."Statement No."));        end;        InitPost(Rec);        Post(Rec);        FinalizePost(Rec);        if PreviewMode then            exit;        if GuiAllowed then            Window.Close();        Commit();    end;    var        BankAcc: Record "Bank Account";        BankAccLedgEntry: Record "Bank Account Ledger Entry";        CheckLedgEntry: Record "Check Ledger Entry";        GenJnlLine: Record "Gen. Journal Line";        GLSetup: Record "General Ledger Setup";        SourceCodeSetup: Record "Source Code Setup";        GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line";        Window: Dialog;        SourceCode: Code[10];        PostedStamentNo: Code[20];        TotalAmount: Decimal;        TotalAppliedAmount: Decimal;        Lines: Integer;        Difference: Decimal;        PreviewMode: Boolean;        PostPaymentsOnly: Boolean;#pragma warning disable AA0470        PostingLinesTxt: Label 'Posting lines              #2######';        StatementEndingBalanceErr: Label '%1 must be equal to Total Balance.';#pragma warning restore AA0470#pragma warning disable AA0074#pragma warning disable AA0470        Text003: Label 'The application is not correct. The total amount applied is %1; it should be %2.';        Text004: Label 'The total difference is %1. It must be %2.';#pragma warning restore AA0470#pragma warning restore AA0074        ExcessiveAmtErr: Label 'You must apply the excessive amount of %1 %2 manually.', Comment = '%1 a decimal number, %2 currency code';        NotFullyAppliedErr: Label 'One or more payments are not fully applied.\\The sum of applied amounts is %1. It must be %2.', Comment = '%1 - total applied amount, %2 - total transaction amount';        LineNoTAppliedErr: Label 'The line with transaction date %1 and transaction text ''%2'' is not applied. You must apply all lines.', Comment = '%1 - transaction date, %2 - arbitrary text';        TransactionAlreadyReconciledErr: Label 'The line with transaction date %1 and transaction text ''%2'' is already reconciled.\\You must remove it from the payment reconciliation journal before posting.', Comment = '%1 - transaction date, %2 - arbitrary text';        EventNameTelemetryTxt: Label 'Post bank reconciliation', Locked = true;        EventNameTelemetryPmtTxt: Label 'Post payment application', Locked = true;        PaymentRecCategoryLbl: Label 'AL Payment Reconciliation', Locked = true;        BankAccountRecCategoryLbl: Label 'AL Bank Account Rec', Locked = true;        MissingBankAccReconLineQst: Label 'There''s nothing to post because the reconciliation doesn''t contain any entries.\\Do you want to continue?';        EmptyDescriptionTxt: Label 'Autogenerated blank entry';        PartialApplicationBankLedgerEntryQst: Label 'Line %1 relates to a bank ledger entry that isn''t fully reconciled. Carefully review the entry before proceeding. Partial applications can make your financial records inaccurate, so they aren''t recommended.\\Do you want to continue?', Comment = '%1 - Statement Line No.';    /// <summary>    /// Runs the posting process in preview mode to validate transactions before final posting.    /// Enables users to review the impact of posting without committing changes to the database,    /// providing validation of applied amounts, account assignments, and posting calculations.    /// </summary>    /// <param name="BankAccReconciliation">Bank reconciliation document to preview for posting.</param>    /// <returns>True if preview completed successfully; false if validation errors occurred.</returns>    [Scope('OnPrem')]    [CommitBehavior(CommitBehavior::Ignore)]    procedure RunPreview(var BankAccReconciliation: Record "Bank Acc. Reconciliation"): Boolean    begin        PreviewMode := true;        InitPost(BankAccReconciliation);        Post(BankAccReconciliation);        FinalizePost(BankAccReconciliation);        exit(true);    end;    local procedure InitPost(var BankAccRecon: Record "Bank Acc. Reconciliation")    begin        OnBeforeInitPost(BankAccRecon);        GLSetup.Get();        case BankAccRecon."Statement Type" of            BankAccRecon."Statement Type"::"Bank Reconciliation":                begin                    BankAccRecon.TestField("Statement Date");                    CheckLinesMatchEndingBalance(BankAccRecon, Difference);                end;            BankAccRecon."Statement Type"::"Payment Application":                begin                    SourceCodeSetup.Get();                    SourceCode := SourceCodeSetup."Payment Reconciliation Journal";                    PostPaymentsOnly := BankAccRecon."Post Payments Only";                    if PreviewMode then                        exit;                    if not PostPaymentsOnly then                        if GuiAllowed then begin                            if PAGE.RunModal(Page::"Post Pmts and Rec. Bank Acc.", BankAccRecon) <> ACTION::LookupOK then                                Error('');                            BankAccRecon.Get(BankAccRecon."Statement Type", BankAccRecon."Bank Account No.", BankAccRecon."Statement No.");                            CheckLinesMatchEndingBalance(BankAccRecon, Difference);                        end;                end;        end;    end;    local procedure StoreFieldsPrePosting(BankAccRecon: Record "Bank Acc. Reconciliation"; var PrePostingOutstdPayments: Decimal; var PrePostingOutstdBankTransactions: Decimal; var PrePostingGLBalance: Decimal; var PrePostingTotalPositiveDifference: Decimal; var PrePostingTotalNegativeDifference: Decimal)    var        PreBankAcc: Record "Bank Account";        BankAccPostingGroup: Record "Bank Account Posting Group";        BankAccReconTest: Codeunit "Bank Acc. Recon. Test";    begin        BankAccRecon.CalcFields(            "Total Applied Amount",            "Total Outstd Bank Transactions",            "Total Outstd Payments",            "Total Unposted Applied Amount"        );        PrePostingOutstdPayments := BankAccReconTest.TotalOutstandingPayments(BankAccRecon);        PrePostingOutstdBankTransactions := BankAccReconTest.TotalOutstandingBankTransactions(BankAccRecon);        PrePostingTotalPositiveDifference := BankAccReconTest.TotalPositiveDifference(BankAccRecon);        PrePostingTotalNegativeDifference := BankAccReconTest.TotalNegativeDifference(BankAccRecon);        PreBankAcc.SetFilter("Date Filter", '..%1', BankAccRecon."Statement Date");        PreBankAcc.SetAutoCalcFields("Balance at Date");        if PreBankAcc.Get(BankAccRecon."Bank Account No.") then            if BankAccPostingGroup.Get(PreBankAcc."Bank Acc. Posting Group") then                PrePostingGLBalance := BankAccReconTest.GetGLAccountBalanceLCY(PreBankAcc, BankAccPostingGroup, BankAccRecon."Statement Date");    end;    local procedure Post(BankAccRecon: Record "Bank Acc. Reconciliation")    var        BankAccReconLine: Record "Bank Acc. Reconciliation Line";        BankAccRecMatchBuffer: Record "Bank Acc. Rec. Match Buffer";        FeatureTelemetry: Codeunit "Feature Telemetry";        AppliedAmount: Decimal;        PrePostingOutstdPayments: Decimal;        PrePostingOutstdBankTransactions: Decimal;        PrePostingGLBalance: Decimal;        PrePostingTotalPositiveDifference: Decimal;        PrePostingTotalNegativeDifference: Decimal;        TotalTransAmtNotAppliedErr: Text;    begin        OnBeforePost(BankAccRecon, BankAccReconLine);        case BankAccRecon."Statement Type" of            BankAccRecon."Statement Type"::"Bank Reconciliation":                FeatureTelemetry.LogUptake('0000JLO', BankAccRecon.GetBankReconciliationTelemetryFeatureName(), Enum::"Feature Uptake Status"::Used);            BankAccRecon."Statement Type"::"Payment Application":                FeatureTelemetry.LogUptake('0000KMI', BankAccReconLine.GetPaymentRecJournalTelemetryFeatureName(), Enum::"Feature Uptake Status"::Used);        end;        StoreFieldsPrePosting(BankAccRecon, PrePostingOutstdPayments, PrePostingOutstdBankTransactions, PrePostingGLBalance, PrePostingTotalPositiveDifference, PrePostingTotalNegativeDifference);        // Run through lines        BankAccReconLine.FilterBankRecLines(BankAccRecon);        OnPostAfterFilterBankAccRecLines(BankAccReconLine, BankAccRecon);        TotalAmount := 0;        TotalAppliedAmount := 0;        Lines := 0;        if BankAccReconLine.IsEmpty() then            if Confirm(MissingBankAccReconLineQst) then                InsertEmptyBankAccReconLine(BankAccRecon)            else                Error('');        BankAccLedgEntry.LockTable();        CheckLedgEntry.LockTable();        PostedStamentNo := GetPostedStamentNo(BankAccRecon);        if BankAccReconLine.FindSet() then            repeat                Lines := Lines + 1;                if GuiAllowed then                    if not PreviewMode then                        Window.Update(2, Lines);                AppliedAmount := 0;                BankAccReconLine.FilterManyToOneMatches(BankAccRecMatchBuffer);                if (BankAccRecon."Statement Type" = BankAccRecon."Statement Type"::"Bank Reconciliation") and BankAccRecMatchBuffer.FindFirst() then begin                    if (not BankAccRecMatchBuffer."Is Processed") then                        CloseBankAccLEManyToOne(BankAccRecMatchBuffer, AppliedAmount, BankAccRecon."Statement Date");                end else begin                    // Adjust entries                    // Test amount and settled amount                    case BankAccRecon."Statement Type" of                        BankAccRecon."Statement Type"::"Bank Reconciliation":                            CloseBankAccLedgEntry(BankAccReconLine, AppliedAmount, BankAccRecon."Statement Date");                        BankAccRecon."Statement Type"::"Payment Application":                            PostPaymentApplications(BankAccReconLine, AppliedAmount);                    end;                    OnBeforeAppliedAmountCheck(BankAccReconLine, AppliedAmount);                    BankAccReconLine.TestField("Applied Amount", AppliedAmount);                end;                TotalAmount += BankAccReconLine."Statement Amount";                TotalAppliedAmount += AppliedAmount;            until BankAccReconLine.Next() = 0;        // Test amount        if BankAccRecon."Statement Type" = BankAccRecon."Statement Type"::"Payment Application" then            TotalTransAmtNotAppliedErr := NotFullyAppliedErr        else            TotalTransAmtNotAppliedErr := Text003;        if TotalAmount <> TotalAppliedAmount then            Error(              TotalTransAmtNotAppliedErr,              TotalAppliedAmount, TotalAmount);        if Difference <> 0 then            Error(Text004, Difference, 0);        if PreviewMode then            exit;        // Get bank        if not PostPaymentsOnly then            UpdateBank(BankAccRecon, TotalAmount);        case BankAccRecon."Statement Type" of            BankAccRecon."Statement Type"::"Bank Reconciliation":                begin                    TransferToBankStmt(BankAccRecon, PrePostingOutstdPayments, PrePostingOutstdBankTransactions, PrePostingGLBalance, PrePostingTotalPositiveDifference, PrePostingTotalNegativeDifference);                    FeatureTelemetry.LogUsage('0000JLP', BankAccRecon.GetBankReconciliationTelemetryFeatureName(), EventNameTelemetryTxt);                    Session.LogMessage('0000JLQ', Format(Lines), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl);                end;            BankAccRecon."Statement Type"::"Payment Application":                begin                    HandlePaymentApplicationTransfer(BankAccRecon, PrePostingOutstdPayments, PrePostingOutstdBankTransactions, PrePostingGLBalance, PrePostingTotalPositiveDifference, PrePostingTotalNegativeDifference);                    FeatureTelemetry.LogUsage('0000KMJ', BankAccReconLine.GetPaymentRecJournalTelemetryFeatureName(), EventNameTelemetryPmtTxt);                    Session.LogMessage('0000KMK', Format(Lines), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', PaymentRecCategoryLbl);                end;        end;    end;    local procedure HandlePaymentApplicationTransfer(BankAccRecon: Record "Bank Acc. Reconciliation"; PrePostingOutstdPayments: Decimal; PrePostingOutstdBankTransactions: Decimal; PrePostingGLBalance: Decimal; PrePostingTotalPositiveDifference: Decimal; PrePostingTotalNegativeDifference: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeHandlePaymentApplicationTransfer(BankAccRecon, IsHandled);        if IsHandled then            exit;        TransferToPostPmtAppln(BankAccRecon);        if not BankAccRecon."Post Payments Only" then            TransferToBankStmt(BankAccRecon, PrePostingOutstdPayments, PrePostingOutstdBankTransactions, PrePostingGLBalance, PrePostingTotalPositiveDifference, PrePostingTotalNegativeDifference);    end;    local procedure FinalizePost(BankAccRecon: Record "Bank Acc. Reconciliation")    var        UpdateAnalysisView: Codeunit "Update Analysis View";        CreationDateTime: DateTime;        MatchedWithAI: Boolean;        LineCount: Integer;        TelemetryCategories: Dictionary of [Text, Text];        DurationUntilPosting: BigInteger;    begin        if PreviewMode then            exit;        OnBeforeFinalizePost(BankAccRecon);        CreationDateTime := BankAccRecon.SystemCreatedAt;        MatchedWithAI := AIMatchProposalsExist(BankAccRecon);        DeleteRelatedRecords(BankAccRecon, LineCount);        UpdateAnalysisView.UpdateAll(0, true);        TelemetryCategories.Add('Category', BankAccountRecCategoryLbl);        TelemetryCategories.Add('MatchedWithAI', Format(MatchedWithAI, 0, 9));        TelemetryCategories.Add('NumberOfLines', Format(LineCount));        if TryCalculateDurationToPost(DurationUntilPosting, CreationDateTime) then            Session.LogMessage('0000LHY', Format(DurationUntilPosting), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, TelemetryCategories);        OnAfterFinalizePost(BankAccRecon);    end;    local procedure DeleteRelatedRecords(var BankAccReconciliation: Record "Bank Acc. Reconciliation"; var LineCount: Integer)    var        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";        AppliedPaymentEntry: Record "Applied Payment Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeDeleteRelatedRecords(BankAccReconciliation, IsHandled);        if IsHandled then            exit;        if BankAccReconciliationLine.LinesExist(BankAccReconciliation) then            repeat                AppliedPaymentEntry.FilterAppliedPmtEntry(BankAccReconciliationLine);                AppliedPaymentEntry.DeleteAll();                BankAccReconciliationLine.Delete();                BankAccReconciliationLine.ClearDataExchEntries();                LineCount += 1;            until BankAccReconciliationLine.Next() = 0;        BankAccReconciliation.Find();        BankAccReconciliation.Delete();    end;    [TryFunction]    local procedure TryCalculateDurationToPost(var DurationUntilPosting: BigInteger; CreationDateTime: DateTime)    begin        DurationUntilPosting := CurrentDateTime() - CreationDateTime;    end;    local procedure AIMatchProposalsExist(var BankAccReconciliation: Record "Bank Acc. Reconciliation"): Boolean    var        PaymentMatchingDetails: Record "Payment Matching Details";    begin        PaymentMatchingDetails.SetRange("Statement Type", BankAccReconciliation."Statement Type");        PaymentMatchingDetails.SetRange("Bank Account No.", BankAccReconciliation."Bank Account No.");        PaymentMatchingDetails.SetRange("Statement No.", BankAccReconciliation."Statement No.");        PaymentMatchingDetails.SetFilter(Message, '*Copilot*');        exit(not PaymentMatchingDetails.IsEmpty());    end;    local procedure CheckLinesMatchEndingBalance(BankAccRecon: Record "Bank Acc. Reconciliation"; var Difference: Decimal)    var        BankAccReconLine: Record "Bank Acc. Reconciliation Line";    begin        BankAccReconLine.LinesExist(BankAccRecon);        BankAccReconLine.CalcSums(BankAccReconLine."Statement Amount", BankAccReconLine.Difference);        OnCheckLinesMatchEndingBalanceOnAfterCalcSums(BankAccReconLine);        if BankAccReconLine."Statement Amount" <>           BankAccRecon."Statement Ending Balance" - BankAccRecon."Balance Last Statement"        then            Error(StatementEndingBalanceErr, BankAccRecon.FieldCaption("Statement Ending Balance"));        Difference := BankAccReconLine.Difference;    end;    local procedure CloseBankAccLEManyToOne(BankAccRecMatchBuffer: Record "Bank Acc. Rec. Match Buffer"; var AppliedAmount: Decimal; StatementDate: Date);    var        BankAccRecMatchBufferCopy: Record "Bank Acc. Rec. Match Buffer";        BankAccRecLine: Record "Bank Acc. Reconciliation Line";        LedgerEntryNo: Integer;        TotalRecLinesAmount: Decimal;    begin        BankAccRecMatchBufferCopy.SetRange("Bank Account No.", BankAccRecMatchBuffer."Bank Account No.");        BankAccRecMatchBufferCopy.SetRange("Statement No.", BankAccRecMatchBuffer."Statement No.");        BankAccRecMatchBufferCopy.SetRange("Match ID", BankAccRecMatchBuffer."Match ID");        if (not BankAccRecMatchBufferCopy.IsEmpty()) then            if BankAccRecMatchBufferCopy.FindSet() then                repeat                    LedgerEntryNo := BankAccRecMatchBufferCopy."Ledger Entry No.";                    BankAccRecMatchBufferCopy."Is Processed" := true;                    BankAccRecMatchBufferCopy.Modify();                    BankAccRecLine.SetRange("Bank Account No.", BankAccRecMatchBufferCopy."Bank Account No.");                    BankAccRecLine.SetRange("Statement No.", BankAccRecMatchBufferCopy."Statement No.");                    BankAccRecLine.SetRange("Statement Line No.", BankAccRecMatchBufferCopy."Statement Line No.");                    if BankAccRecLine.FindFirst() then                        TotalRecLinesAmount += BankAccRecLine."Statement Amount";                until BankAccRecMatchBufferCopy.Next() = 0;        BankAccLedgEntry.Get(LedgerEntryNo);        BankAccLedgEntry.TestField("Remaining Amount", TotalRecLinesAmount);        AppliedAmount += BankAccLedgEntry."Remaining Amount";        BankAccLedgEntry."Remaining Amount" := 0;        BankAccLedgEntry.Open := false;        BankAccLedgEntry."Closed at Date" := StatementDate;        BankAccLedgEntry."Statement Status" := BankAccLedgEntry."Statement Status"::Closed;        OnCloseBankAccLedgEntryOnBeforeBankAccLedgEntryModify(BankAccLedgEntry, BankAccRecLine);        BankAccLedgEntry.Modify();        CheckLedgEntry.Reset();        CheckLedgEntry.SetCurrentKey("Bank Account Ledger Entry No.");        CheckLedgEntry.SetRange(            "Bank Account Ledger Entry No.", BankAccLedgEntry."Entry No.");        CheckLedgEntry.SetRange(Open, true);        if CheckLedgEntry.Find('-') then            repeat                CheckLedgEntry.TestField(Open, true);                CheckLedgEntry.TestField(                    "Statement Status",                    CheckLedgEntry."Statement Status"::"Bank Acc. Entry Applied");                CheckLedgEntry.Open := false;                CheckLedgEntry."Statement Status" := CheckLedgEntry."Statement Status"::Closed;                CheckLedgEntry.Modify();            until CheckLedgEntry.Next() = 0;    end;    local procedure CloseBankAccLedgEntry(BankAccReconLine: Record "Bank Acc. Reconciliation Line"; var AppliedAmount: Decimal; StatementClosingDate: Date)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCloseBankAccLedgEntry(BankAccReconLine, AppliedAmount, IsHandled);        if IsHandled then            exit;        BankAccLedgEntry.Reset();        BankAccLedgEntry.SetCurrentKey("Bank Account No.", Open);        BankAccLedgEntry.SetRange("Bank Account No.", BankAccReconLine."Bank Account No.");        BankAccLedgEntry.SetRange(Open, true);        BankAccLedgEntry.SetFilter("Statement Status", '%1|%2', BankAccLedgEntry."Statement Status"::"Bank Acc. Entry Applied", BankAccLedgEntry."Statement Status"::"Check Entry Applied");        BankAccLedgEntry.SetRange("Statement No.", BankAccReconLine."Statement No.");        BankAccLedgEntry.SetRange("Statement Line No.", BankAccReconLine."Statement Line No.");        OnCloseBankAccLedgEntryOnAfterBankAccLedgEntrySetFilters(BankAccLedgEntry, BankAccReconLine);        if BankAccLedgEntry.FindSet(true) then            repeat                AppliedAmount += BankAccLedgEntry."Remaining Amount";                BankAccLedgEntry."Remaining Amount" := 0;                BankAccLedgEntry.Open := false;                BankAccLedgEntry."Closed at Date" := StatementClosingDate;                BankAccLedgEntry."Statement Status" := BankAccLedgEntry."Statement Status"::Closed;                BankAccLedgEntry."Statement No." := PostedStamentNo;                OnCloseBankAccLedgEntryOnBeforeBankAccLedgEntryModify(BankAccLedgEntry, BankAccReconLine);                BankAccLedgEntry.Modify();                CheckLedgEntry.Reset();                CheckLedgEntry.SetCurrentKey("Bank Account Ledger Entry No.");                CheckLedgEntry.SetRange(                  "Bank Account Ledger Entry No.", BankAccLedgEntry."Entry No.");                CheckLedgEntry.SetRange(Open, true);                if CheckLedgEntry.Find('-') then                    repeat                        CheckLedgEntry.TestField(Open, true);                        CheckLedgEntry.TestField("Statement No.", BankAccReconLine."Statement No.");                        CheckLedgEntry.TestField("Statement Line No.", BankAccReconLine."Statement Line No.");                        CheckLedgEntry.Open := false;                        CheckLedgEntry."Statement Status" := CheckLedgEntry."Statement Status"::Closed;                        OnCloseBankAccLedgEntryOnBeforeCheckLedgEntryModify(CheckLedgEntry, BankAccReconLine);                        CheckLedgEntry.Modify();                    until CheckLedgEntry.Next() = 0;            until BankAccLedgEntry.Next() = 0;    end;    local procedure PostPaymentApplications(BankAccReconLine: Record "Bank Acc. Reconciliation Line"; var AppliedAmount: Decimal)    var        BankAccReconciliation: Record "Bank Acc. Reconciliation";        Currency: Record Currency;        CurrExchRate: Record "Currency Exchange Rate";        AppliedPmtEntry: Record "Applied Payment Entry";        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        DimensionManagement: Codeunit DimensionManagement;        ConfirmManagement: Codeunit "Confirm Management";        PaymentLineAmount: Decimal;        RemainingAmount: Decimal;        IsApplied: Boolean;        IsHandled: Boolean;        ContinueWithPartialApplicationOfBLE: Boolean;    begin        IsHandled := false;        OnBeforePostPaymentApplications(BankAccReconLine, AppliedAmount, IsHandled);        if IsHandled then            exit;        if BankAccReconLine.IsTransactionPostedAndReconciled() then            Error(TransactionAlreadyReconciledErr, BankAccReconLine."Transaction Date", BankAccReconLine."Transaction Text");        OnPostPaymentApplicationsOnAfterTransactionPostedAndReconciledCheck(BankAccReconLine, AppliedAmount, SourceCode);        if BankAccReconLine."Account No." = '' then            Error(LineNoTAppliedErr, BankAccReconLine."Transaction Date", BankAccReconLine."Transaction Text");        BankAcc.Get(BankAccReconLine."Bank Account No.");        GenJnlLine.Init();        GenJnlLine.SetSuppressCommit(true);        GenJnlLine."Document Type" := GenJnlLine."Document Type"::Payment;        if IsRefund(BankAccReconLine) then            if BankAccReconLine."Account Type" = BankAccReconLine."Account Type"::Employee then                GenJnlLine."Document Type" := GenJnlLine."Document Type"::" "            else                GenJnlLine."Document Type" := GenJnlLine."Document Type"::Refund;        GenJnlLine."Posting Date" := BankAccReconLine."Transaction Date";        GenJnlLine."VAT Reporting Date" := BankAccReconLine."Transaction Date";        GenJnlLine."Account Type" := Enum::"Gen. Journal Account Type".FromInteger(BankAccReconLine.GetAppliedToAccountType());        BankAccReconciliation.Get(          BankAccReconLine."Statement Type", BankAccReconLine."Bank Account No.", BankAccReconLine."Statement No.");        GenJnlLine."Copy VAT Setup to Jnl. Lines" := BankAccReconciliation."Copy VAT Setup to Jnl. Line";        GenJnlLine.Validate("Account No.", BankAccReconLine.GetAppliedToAccountNo());        GenJnlLine."Dimension Set ID" := BankAccReconLine."Dimension Set ID";        DimensionManagement.UpdateGlobalDimFromDimSetID(          BankAccReconLine."Dimension Set ID", GenJnlLine."Shortcut Dimension 1 Code", GenJnlLine."Shortcut Dimension 2 Code");        GenJnlLine.Description := BankAccReconLine.GetDescription();        GenJnlLine."Document No." := PostedStamentNo;        GenJnlLine."Bal. Account Type" := GenJnlLine."Bal. Account Type"::"Bank Account";        GenJnlLine."Bal. Account No." := BankAcc."No.";        GenJnlLine."Source Code" := SourceCode;        GenJnlLine."Allow Zero-Amount Posting" := true;        GenJnlLine."Applies-to ID" := BankAccReconLine.GetAppliesToID();        if GLSetup."Journal Templ. Name Mandatory" then begin            GLSetup.TestField("Bank Acc. Recon. Template Name");            GLSetup.TestField("Bank Acc. Recon. Batch Name");            GenJnlLine."Journal Template Name" := GLSetup."Bank Acc. Recon. Template Name";            GenJnlLine."Journal Batch Name" := GLSetup."Bank Acc. Recon. Batch Name";        end;        IsApplied := false;        IsHandled := false;        OnPostPaymentApplicationsOnAfterInitGenJnlLine(GenJnlLine, BankAccReconLine, IsApplied, AppliedAmount, PaymentLineAmount, IsHandled);        if IsHandled then            exit;        if AppliedPmtEntry.AppliedPmtEntryLinesExist(BankAccReconLine) then            repeat                AppliedAmount += AppliedPmtEntry."Applied Amount" - AppliedPmtEntry."Applied Pmt. Discount";                PaymentLineAmount += AppliedPmtEntry."Applied Amount" - AppliedPmtEntry."Applied Pmt. Discount";                AppliedPmtEntry.TestField("Account Type", BankAccReconLine."Account Type");                AppliedPmtEntry.TestField("Account No.", BankAccReconLine."Account No.");                if AppliedPmtEntry."Applies-to Entry No." <> 0 then begin                    case AppliedPmtEntry."Account Type" of                        AppliedPmtEntry."Account Type"::Customer:                            ApplyCustLedgEntry(                              AppliedPmtEntry, GenJnlLine."Applies-to ID", GenJnlLine."Posting Date", 0D, 0D, AppliedPmtEntry."Applied Pmt. Discount");                        AppliedPmtEntry."Account Type"::Vendor:                            ApplyVendLedgEntry(                              AppliedPmtEntry, GenJnlLine."Applies-to ID", GenJnlLine."Posting Date", 0D, 0D, AppliedPmtEntry."Applied Pmt. Discount");                        AppliedPmtEntry."Account Type"::Employee:                            ApplyEmployeeLedgEntry(                              AppliedPmtEntry, GenJnlLine."Applies-to ID", GenJnlLine."Posting Date", 0D, 0D, AppliedPmtEntry."Applied Pmt. Discount");                        AppliedPmtEntry."Account Type"::"Bank Account":                            begin                                BankAccountLedgerEntry.Get(AppliedPmtEntry."Applies-to Entry No.");                                RemainingAmount := BankAccountLedgerEntry."Remaining Amount";                                case true of                                    RemainingAmount = AppliedPmtEntry."Applied Amount":                                        begin                                            if not PostPaymentsOnly then                                                CloseBankAccountLedgerEntry(AppliedPmtEntry."Applies-to Entry No.", AppliedPmtEntry."Applied Amount", BankAccReconciliation."Statement Date", BankAccReconLine."Statement Line No.");                                            PaymentLineAmount -= AppliedPmtEntry."Applied Amount";                                        end;                                    Abs(RemainingAmount) > Abs(AppliedPmtEntry."Applied Amount"):                                        begin                                            ContinueWithPartialApplicationOfBLE := ConfirmManagement.GetResponseOrDefault(StrSubstNo(PartialApplicationBankLedgerEntryQst, AppliedPmtEntry."Statement Line No."), false);                                            Session.LogMessage('0000KSG', 'Partial application of BLE', Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::All, 'Continue', Format(ContinueWithPartialApplicationOfBLE));                                            if not ContinueWithPartialApplicationOfBLE then                                                Error('');                                            if not PostPaymentsOnly then begin                                                BankAccountLedgerEntry."Remaining Amount" -= AppliedPmtEntry."Applied Amount";                                                BankAccountLedgerEntry.Modify();                                            end;                                            PaymentLineAmount -= AppliedPmtEntry."Applied Amount";                                        end;                                    Abs(RemainingAmount) < Abs(AppliedPmtEntry."Applied Amount"):                                        begin                                            if not PostPaymentsOnly then                                                CloseBankAccountLedgerEntry(AppliedPmtEntry."Applies-to Entry No.", RemainingAmount, BankAccReconciliation."Statement Date", BankAccReconLine."Statement Line No.");                                            PaymentLineAmount -= RemainingAmount;                                        end;                                end;                            end;                        else                            OnPostPaymentApplicationsOnAccountTypeCaseElse(AppliedPmtEntry, GenJnlLine);                    end;                    IsApplied := true;                end;            until AppliedPmtEntry.Next() = 0;        if PaymentLineAmount <> 0 then begin            if not IsApplied then                GenJnlLine."Applies-to ID" := '';            if (GenJnlLine."Account Type" <> GenJnlLine."Account Type"::"Bank Account") or               (GenJnlLine."Currency Code" = BankAcc."Currency Code")            then begin                GenJnlLine.Validate("Currency Code", BankAcc."Currency Code");                Currency.Initialize(GenJnlLine."Currency Code");                GenJnlLine.Amount := Round(-PaymentLineAmount, Currency."Amount Rounding Precision");                if GenJnlLine."Currency Code" <> '' then                    GenJnlLine."Amount (LCY)" := Round(                        CurrExchRate.ExchangeAmtFCYToLCY(                          GenJnlLine."Posting Date", GenJnlLine."Currency Code",                          GenJnlLine.Amount, GenJnlLine."Currency Factor"));                GenJnlLine.Validate("VAT %");                GenJnlLine.Validate("Bal. VAT %")            end else                Error(ExcessiveAmtErr, PaymentLineAmount, GLSetup.GetCurrencyCode(BankAcc."Currency Code"));            OnPostPaymentApplicationsOnBeforeValidateApplyRequirements(BankAccReconLine, GenJnlLine, AppliedAmount);            GenJnlLine.ValidateApplyRequirements(GenJnlLine);            GenJnlPostLine.RunWithCheck(GenJnlLine);            OnPostPaymentApplicationsOnAfterPostGenJnlLine(GenJnlLine, GenJnlPostLine);            if not PostPaymentsOnly then begin                BankAccountLedgerEntry.SetRange(Open, true);                BankAccountLedgerEntry.SetRange("Bank Account No.", BankAcc."No.");                BankAccountLedgerEntry.SetRange("Document Type", GenJnlLine."Document Type");                BankAccountLedgerEntry.SetRange("Document No.", PostedStamentNo);                BankAccountLedgerEntry.SetRange("Posting Date", GenJnlLine."Posting Date");                OnPostPaymentApplicationsOnAfterBankAccountLedgerEntrySetFilters(BankAccountLedgerEntry, GenJnlLine);                if BankAccountLedgerEntry.FindLast() then                    CloseBankAccountLedgerEntry(BankAccountLedgerEntry."Entry No.", BankAccountLedgerEntry.Amount, BankAccReconciliation."Statement Date", BankAccReconLine."Statement Line No.");            end;        end;    end;    local procedure UpdateBank(BankAccRecon: Record "Bank Acc. Reconciliation"; Amt: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateBank(BankAccRecon, BankAcc, IsHandled, Amt, PostedStamentNo);        if IsHandled then            exit;        BankAcc.LockTable();        BankAcc.Get(BankAccRecon."Bank Account No.");        BankAcc.TestField(Blocked, false);        BankAcc."Last Statement No." := PostedStamentNo;        BankAcc."Balance Last Statement" := BankAccRecon."Balance Last Statement" + Amt;        BankAcc.Modify();    end;    local procedure TransferToBankStmt(BankAccRecon: Record "Bank Acc. Reconciliation"; PrePostingOutstdPayments: Decimal; PrePostingOutstdBankTransactions: Decimal; PrePostingGLBalance: Decimal; PrePostingTotalPositiveDifference: Decimal; PrePostingTotalNegativeDifference: Decimal)    var        BankAccStmt: Record "Bank Account Statement";        BankAccStmtLine: Record "Bank Account Statement Line";        BankAccReconLine: Record "Bank Acc. Reconciliation Line";        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        AppliedPaymentEntry: Record "Applied Payment Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTransferToBankStmt(BankAccRecon, PrePostingOutstdPayments, PrePostingOutstdBankTransactions, PrePostingGLBalance, PrePostingTotalPositiveDifference, PrePostingTotalNegativeDifference, IsHandled);        if IsHandled then            exit;        BankAccStmt.Init();        BankAccStmt.TransferFields(BankAccRecon);        BankAccStmt."Statement No." := PostedStamentNo;        if BankAccReconLine.LinesExist(BankAccRecon) then            repeat                BankAccStmtLine.TransferFields(BankAccReconLine);                BankAccStmtLine."Statement No." := BankAccStmt."Statement No.";                OnTransferToBankStmtOnBeforeBankAccStmtLineInsert(BankAccStmtLine, BankAccReconLine);                if AppliedPaymentEntry.AppliedPmtEntryLinesExist(BankAccReconLine) then                    if (AppliedPaymentEntry."Applies-to Entry No." <> 0) and (AppliedPaymentEntry."Account Type" = AppliedPaymentEntry."Account Type"::"Bank Account") then begin                        BankAccountLedgerEntry.Get(AppliedPaymentEntry."Applies-to Entry No.");                        BankAccStmtLine.Difference := BankAccountLedgerEntry."Remaining Amount";                    end;                BankAccStmtLine.Insert();                BankAccReconLine.ClearDataExchEntries();            until BankAccReconLine.Next() = 0;        BankAccStmtLine.SetRange("Bank Account No.", BankAccStmt."Bank Account No.");        BankAccStmtLine.SetRange("Statement No.", BankAccStmt."Statement No.");        BankAccStmtLine.CalcSums("Statement Amount");        BankAccStmt."G/L Balance at Posting Date" := PrePostingGLBalance;        BankAccStmt."Outstd. Payments at Posting" := PrePostingOutstdPayments;        BankAccStmt."Outstd. Transact. at Posting" := PrePostingOutstdBankTransactions;        BankAccStmt."Total Pos. Diff. at Posting" := PrePostingTotalPositiveDifference;        BankAccStmt."Total Neg. Diff. at Posting" := PrePostingTotalNegativeDifference;        OnBeforeBankAccStmtInsert(BankAccStmt, BankAccRecon);        BankAccStmt.Insert();    end;    local procedure GetPostedStamentNo(BankAccRecon: Record "Bank Acc. Reconciliation") StatementNo: Code[20]    var        BankAccStmt: Record "Bank Account Statement";    begin        StatementNo := BankAccRecon."Statement No.";        BankAccStmt.SetRange("Bank Account No.", BankAccRecon."Bank Account No.");        BankAccStmt.SetRange("Statement No.", BankAccRecon."Statement No.");        if not BankAccStmt.IsEmpty() then            StatementNo := GetNextStatementNoAndUpdateBankAccount(BankAccRecon."Bank Account No.");    end;    local procedure TransferToPostPmtAppln(BankAccRecon: Record "Bank Acc. Reconciliation")    var        PostedPmtReconHdr: Record "Posted Payment Recon. Hdr";        PostedPmtReconLine: Record "Posted Payment Recon. Line";        BankAccReconLine: Record "Bank Acc. Reconciliation Line";        TypeHelper: Codeunit "Type Helper";        FieldLength: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeTransferToPostPmtAppln(BankAccRecon, IsHandled);        if IsHandled then            exit;        if BankAccReconLine.LinesExist(BankAccRecon) then            repeat                PostedPmtReconLine.TransferFields(BankAccReconLine);                FieldLength := TypeHelper.GetFieldLength(DATABASE::"Posted Payment Recon. Line",                    PostedPmtReconLine.FieldNo("Applied Document No."));                PostedPmtReconLine."Applied Document No." := CopyStr(BankAccReconLine.GetAppliedToDocumentNo(), 1, FieldLength);                FieldLength := TypeHelper.GetFieldLength(DATABASE::"Posted Payment Recon. Line",                    PostedPmtReconLine.FieldNo("Applied Entry No."));                PostedPmtReconLine."Applied Entry No." := CopyStr(BankAccReconLine.GetAppliedToEntryNo(), 1, FieldLength);                PostedPmtReconLine.Reconciled := not PostPaymentsOnly;                OnTransferToPostPmtApplnOnBeforePostedPmtReconLineInsert(PostedPmtReconLine, BankAccReconLine);                PostedPmtReconLine.Insert();                BankAccReconLine.ClearDataExchEntries();            until BankAccReconLine.Next() = 0;        PostedPmtReconHdr.TransferFields(BankAccRecon);        OnBeforePostedPmtReconInsert(PostedPmtReconHdr, BankAccRecon);        PostedPmtReconHdr.Insert();    end;    /// <summary>    /// Applies a payment entry to a customer ledger entry during bank reconciliation posting.    /// Updates the customer ledger entry with payment application details including discount dates,    /// tolerance calculations, and application amounts. Handles currency exchange rate calculations    /// for foreign currency transactions and integrates with the payment discount calculation engine.    /// </summary>    /// <param name="AppliedPmtEntry">Applied payment entry containing application details and amounts.</param>    /// <param name="AppliesToID">Application identifier for grouping related applications; empty for immediate application.</param>    /// <param name="PostingDate">Date for payment application posting and currency rate calculations.</param>    /// <param name="PmtDiscDueDate">Payment discount due date for discount eligibility calculation.</param>    /// <param name="PmtDiscToleranceDate">Payment discount tolerance date for extended discount availability.</param>    /// <param name="RemPmtDiscPossible">Remaining payment discount amount available for the application.</param>    procedure ApplyCustLedgEntry(AppliedPmtEntry: Record "Applied Payment Entry"; AppliesToID: Code[50]; PostingDate: Date; PmtDiscDueDate: Date; PmtDiscToleranceDate: Date; RemPmtDiscPossible: Decimal)    var        CustLedgEntry: Record "Cust. Ledger Entry";        CurrExchRate: Record "Currency Exchange Rate";        IsHandled: Boolean;    begin        CustLedgEntry.Get(AppliedPmtEntry."Applies-to Entry No.");        CustLedgEntry.TestField(Open);        BankAcc.Get(AppliedPmtEntry."Bank Account No.");        IsHandled := false;        OnBeforeApplyCustLedgEntry(CustLedgEntry, AppliedPmtEntry, BankAcc, AppliesToID, PostingDate, PmtDiscDueDate, PmtDiscToleranceDate, RemPmtDiscPossible, IsHandled);        if IsHandled then            exit;        if AppliesToID = '' then begin            CustLedgEntry."Pmt. Discount Date" := PmtDiscDueDate;            CustLedgEntry."Pmt. Disc. Tolerance Date" := PmtDiscToleranceDate;            CustLedgEntry."Remaining Pmt. Disc. Possible" := RemPmtDiscPossible;            if BankAcc.IsInLocalCurrency() then                CustLedgEntry."Remaining Pmt. Disc. Possible" :=                  CurrExchRate.ExchangeAmount(CustLedgEntry."Remaining Pmt. Disc. Possible", '', CustLedgEntry."Currency Code", PostingDate);        end else begin            CustLedgEntry."Applies-to ID" := AppliesToID;            CustLedgEntry."Amount to Apply" := AppliedPmtEntry.CalcAmountToApply(PostingDate);        end;        if PreviewMode then            CustEntryEditNoCommit(CustLedgEntry)        else            CODEUNIT.Run(CODEUNIT::"Cust. Entry-Edit", CustLedgEntry);    end;    [CommitBehavior(CommitBehavior::Ignore)]    local procedure CustEntryEditNoCommit(var CustLedgerEntry: Record "Cust. Ledger Entry")    begin        CODEUNIT.Run(CODEUNIT::"Cust. Entry-Edit", CustLedgerEntry);    end;    /// <summary>    /// Applies a payment entry to a vendor ledger entry during bank reconciliation posting.    /// Updates the vendor ledger entry with payment application details including discount dates,    /// tolerance calculations, and application amounts. Handles currency exchange rate calculations    /// for foreign currency transactions and manages vendor-specific payment discount processing.    /// </summary>    /// <param name="AppliedPmtEntry">Applied payment entry containing application details and amounts.</param>    /// <param name="AppliesToID">Application identifier for grouping related applications; empty for immediate application.</param>    /// <param name="PostingDate">Date for payment application posting and currency rate calculations.</param>    /// <param name="PmtDiscDueDate">Payment discount due date for discount eligibility calculation.</param>    /// <param name="PmtDiscToleranceDate">Payment discount tolerance date for extended discount availability.</param>    /// <param name="RemPmtDiscPossible">Remaining payment discount amount available for the application.</param>    procedure ApplyVendLedgEntry(AppliedPmtEntry: Record "Applied Payment Entry"; AppliesToID: Code[50]; PostingDate: Date; PmtDiscDueDate: Date; PmtDiscToleranceDate: Date; RemPmtDiscPossible: Decimal)    var        VendLedgEntry: Record "Vendor Ledger Entry";        CurrExchRate: Record "Currency Exchange Rate";        ApplyVendLedgEntryHandled: Boolean;    begin        VendLedgEntry.Get(AppliedPmtEntry."Applies-to Entry No.");        VendLedgEntry.TestField(Open);        BankAcc.Get(AppliedPmtEntry."Bank Account No.");        ApplyVendLedgEntryHandled := false;        OnBeforeApplyVendLedgEntry(VendLedgEntry, AppliedPmtEntry, BankAcc, AppliesToID, PostingDate, PmtDiscDueDate, PmtDiscToleranceDate, RemPmtDiscPossible, ApplyVendLedgEntryHandled);        if not ApplyVendLedgEntryHandled then            if AppliesToID = '' then begin                VendLedgEntry."Pmt. Discount Date" := PmtDiscDueDate;                VendLedgEntry."Pmt. Disc. Tolerance Date" := PmtDiscToleranceDate;                VendLedgEntry."Remaining Pmt. Disc. Possible" := RemPmtDiscPossible;                if BankAcc.IsInLocalCurrency() then                    VendLedgEntry."Remaining Pmt. Disc. Possible" :=                      CurrExchRate.ExchangeAmount(VendLedgEntry."Remaining Pmt. Disc. Possible", '', VendLedgEntry."Currency Code", PostingDate);            end else begin                VendLedgEntry."Applies-to ID" := AppliesToID;                VendLedgEntry."Amount to Apply" := AppliedPmtEntry.CalcAmountToApply(PostingDate);            end;        if PreviewMode then            VendEntryEditNoCommit(VendLedgEntry)        else            CODEUNIT.Run(CODEUNIT::"Vend. Entry-Edit", VendLedgEntry);    end;    [CommitBehavior(CommitBehavior::Ignore)]    local procedure VendEntryEditNoCommit(var VendorLedgerEntry: Record "Vendor Ledger Entry")    begin        CODEUNIT.Run(CODEUNIT::"Vend. Entry-Edit", VendorLedgerEntry);    end;    procedure ApplyEmployeeLedgEntry(AppliedPmtEntry: Record "Applied Payment Entry"; AppliesToID: Code[50]; PostingDate: Date; PmtDiscDueDate: Date; PmtDiscToleranceDate: Date; RemPmtDiscPossible: Decimal)    var        EmployeeLedgerEntry: Record "Employee Ledger Entry";    begin        EmployeeLedgerEntry.Get(AppliedPmtEntry."Applies-to Entry No.");        EmployeeLedgerEntry.TestField(Open);        BankAcc.Get(AppliedPmtEntry."Bank Account No.");        if AppliesToID <> '' then begin            EmployeeLedgerEntry."Applies-to ID" := AppliesToID;            EmployeeLedgerEntry."Amount to Apply" := AppliedPmtEntry.CalcAmountToApply(PostingDate);        end;        if PreviewMode then            EmplEntryEditNoCommit(EmployeeLedgerEntry)        else            CODEUNIT.Run(CODEUNIT::"Empl. Entry-Edit", EmployeeLedgerEntry);    end;    [CommitBehavior(CommitBehavior::Ignore)]    local procedure EmplEntryEditNoCommit(var EmployeeLedgerEntry: Record "Employee Ledger Entry")    begin        CODEUNIT.Run(CODEUNIT::"Empl. Entry-Edit", EmployeeLedgerEntry);    end;    local procedure CloseBankAccountLedgerEntry(EntryNo: Integer; AppliedAmount: Decimal; StatementDate: Date; StatementLineNo: Integer)    var        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        CheckLedgerEntry: Record "Check Ledger Entry";    begin        BankAccountLedgerEntry.Get(EntryNo);        BankAccountLedgerEntry.TestField(Open);        BankAccountLedgerEntry.TestField("Remaining Amount", AppliedAmount);        BankAccountLedgerEntry."Remaining Amount" := 0;        BankAccountLedgerEntry.Open := false;        BankAccountLedgerEntry."Statement Status" := BankAccountLedgerEntry."Statement Status"::Closed;        BankAccountLedgerEntry."Closed at Date" := StatementDate;        BankAccountLedgerEntry."Statement No." := PostedStamentNo;        BankAccountLedgerEntry."Statement Line No." := StatementLineNo;        BankAccountLedgerEntry.Modify();        CheckLedgerEntry.Reset();        CheckLedgerEntry.SetCurrentKey("Bank Account Ledger Entry No.");        CheckLedgerEntry.SetRange(          "Bank Account Ledger Entry No.", BankAccountLedgerEntry."Entry No.");        CheckLedgerEntry.SetRange(Open, true);        if CheckLedgerEntry.FindSet() then            repeat                CheckLedgerEntry.Open := false;                CheckLedgerEntry."Statement Status" := CheckLedgerEntry."Statement Status"::Closed;                CheckLedgEntry."Statement No." := PostedStamentNo;                CheckLedgEntry."Statement Line No." := StatementLineNo;                CheckLedgerEntry.Modify();            until CheckLedgerEntry.Next() = 0;    end;    local procedure GetNextStatementNoAndUpdateBankAccount(BankAccountNo: Code[20]): Code[20]    var        BankAccount: Record "Bank Account";    begin        BankAccount.SetLoadFields("Last Statement No.");        BankAccount.Get(BankAccountNo);        if BankAccount."Last Statement No." <> '' then            BankAccount."Last Statement No." := IncStr(BankAccount."Last Statement No.")        else            BankAccount."Last Statement No." := '1';        BankAccount.Modify();        exit(BankAccount."Last Statement No.");    end;    local procedure IsRefund(BankAccReconLine: Record "Bank Acc. Reconciliation Line"): Boolean    begin        if (BankAccReconLine."Account Type" = BankAccReconLine."Account Type"::Customer) and (BankAccReconLine."Statement Amount" < 0) or            (BankAccReconLine."Account Type" in [BankAccReconLine."Account Type"::Vendor, BankAccReconLine."Account Type"::Employee]) and (BankAccReconLine."Statement Amount" > 0)        then            exit(true);        exit(false);    end;    procedure Preview(var BankAccReconciliationSource: Record "Bank Acc. Reconciliation")    var        BankAccReconPostPreview: Codeunit "Bank. Acc. Recon. Post Preview";        BankAccountReconciliationPost: Codeunit "Bank Acc. Reconciliation Post";    begin        BankAccReconPostPreview.Preview(BankAccountReconciliationPost, BankAccReconciliationSource);    end;    local procedure InsertEmptyBankAccReconLine(BankAccReconciliation: Record "Bank Acc. Reconciliation")    var        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";    begin        BankAccReconciliationLine.Init();        BankAccReconciliationLine."Bank Account No." := BankAccReconciliation."Bank Account No.";        BankAccReconciliationLine."Statement No." := BankAccReconciliation."Statement No.";        BankAccReconciliationLine."Statement Line No." := 10000;        BankAccReconciliationLine."Transaction Date" := BankAccReconciliation."Statement Date";        BankAccReconciliationLine.Description := EmptyDescriptionTxt;        BankAccReconciliationLine.Validate("Statement Amount", 0);        BankAccReconciliationLine.Insert();    end;    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Bank. Acc. Recon. Post Preview", 'OnRunPreview', '', false, false)]    local procedure OnRunPreview(var Result: Boolean; var Subscriber: Codeunit "Bank Acc. Reconciliation Post"; var BankAccReconciliationSource: Record "Bank Acc. Reconciliation")    var        BankAccReconciliation: Record "Bank Acc. Reconciliation";        BankAccountReconciliationPost: Codeunit "Bank Acc. Reconciliation Post";    begin        BankAccountReconciliationPost := Subscriber;        BankAccReconciliation.Copy(BankAccReconciliationSource);        Result := not BankAccountReconciliationPost.RunPreview(BankAccReconciliation);    end;    /// <summary>    /// Event raised before checking the applied amount for a bank account reconciliation line.    /// </summary>    /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param>    /// <param name="AppliedAmount">The applied amount being checked.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeAppliedAmountCheck(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var AppliedAmount: Decimal)    begin    end;    /// <summary>    /// Event raised before inserting a bank account statement record during posting.    /// </summary>    /// <param name="BankAccStatement">The bank account statement record being inserted.</param>    /// <param name="BankAccReconciliation">The bank account reconciliation record being posted.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeBankAccStmtInsert(var BankAccStatement: Record "Bank Account Statement"; BankAccReconciliation: Record "Bank Acc. Reconciliation")    begin    end;    /// <summary>    /// Event raised before closing a bank account ledger entry during reconciliation posting.    /// </summary>    /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param>    /// <param name="AppliedAmount">The applied amount.</param>    /// <param name="IsHandled">Indicates whether the event has been handled.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCloseBankAccLedgEntry(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var AppliedAmount: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Event raised before finalizing the posting process for a bank account reconciliation.    /// </summary>    /// <param name="BankAccReconciliation">The bank account reconciliation record being finalized.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeFinalizePost(var BankAccReconciliation: Record "Bank Acc. Reconciliation")    begin    end;    /// <summary>    /// Event raised before deleting related records during bank account reconciliation posting.    /// </summary>    /// <param name="BankAccReconciliation">The bank account reconciliation record.</param>    /// <param name="IsHandled">Indicates whether the event has been handled.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeDeleteRelatedRecords(BankAccReconciliation: Record "Bank Acc. Reconciliation"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Event raised before posting payment applications for a bank account reconciliation line.    /// </summary>    /// <param name="BankAccReconLine">The bank account reconciliation line record.</param>    /// <param name="AppliedAmount">The applied amount.</param>    /// <param name="IsHandled">Indicates whether the event has been handled.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostPaymentApplications(BankAccReconLine: Record "Bank Acc. Reconciliation Line"; var AppliedAmount: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Event raised after finalizing the posting process for a bank account reconciliation.    /// </summary>    /// <param name="BankAccReconciliation">The bank account reconciliation record that was finalized.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterFinalizePost(var BankAccReconciliation: Record "Bank Acc. Reconciliation")    begin    end;    /// <summary>    /// Event raised before initializing the posting process for a bank account reconciliation.    /// </summary>    /// <param name="BankAccReconciliation">The bank account reconciliation record being initialized.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeInitPost(var BankAccReconciliation: Record "Bank Acc. Reconciliation")    begin    end;    /// <summary>    /// Event raised before posting a bank account reconciliation.    /// </summary>    /// <param name="BankAccReconciliation">The bank account reconciliation record being posted.</param>    /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePost(var BankAccReconciliation: Record "Bank Acc. Reconciliation"; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line")    begin    end;    /// <summary>    /// Event raised before inserting a posted payment reconciliation header record.    /// </summary>    /// <param name="PostedPaymentReconHdr">The posted payment reconciliation header record being inserted.</param>    /// <param name="BankAccReconciliation">The bank account reconciliation record.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforePostedPmtReconInsert(var PostedPaymentReconHdr: Record "Posted Payment Recon. Hdr"; BankAccReconciliation: Record "Bank Acc. Reconciliation")    begin    end;    /// <summary>    /// Event raised before transferring to posted payment application during reconciliation posting.    /// </summary>    /// <param name="BankAccReconciliation">The bank account reconciliation record.</param>    /// <param name="IsHandled">Indicates whether the event has been handled.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTransferToPostPmtAppln(var BankAccReconciliation: Record "Bank Acc. Reconciliation"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Event raised before transferring to bank statement during reconciliation posting.    /// </summary>    /// <param name="BankAccRecon">The bank account reconciliation record.</param>    /// <param name="PrePostingOutstdPayments">The pre-posting outstanding payments amount.</param>    /// <param name="PrePostingOutstdBankTransactions">The pre-posting outstanding bank transactions amount.</param>    /// <param name="PrePostingGLBalance">The pre-posting general ledger balance.</param>    /// <param name="PrePostingTotalPositiveDifference">The pre-posting total positive difference.</param>    /// <param name="PrePostingTotalNegativeDifference">The pre-posting total negative difference.</param>    /// <param name="IsHandled">Indicates whether the event has been handled.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeTransferToBankStmt(var BankAccRecon: Record "Bank Acc. Reconciliation"; PrePostingOutstdPayments: Decimal; PrePostingOutstdBankTransactions: Decimal; PrePostingGLBalance: Decimal; PrePostingTotalPositiveDifference: Decimal; PrePostingTotalNegativeDifference: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Event raised after calculating sums when checking if lines match ending balance.    /// </summary>    /// <param name="BankAccReconLine">The bank account reconciliation line record.</param>    [IntegrationEvent(false, false)]    local procedure OnCheckLinesMatchEndingBalanceOnAfterCalcSums(var BankAccReconLine: Record "Bank Acc. Reconciliation Line")    begin    end;    /// <summary>    /// Event raised before modifying bank account ledger entry when closing bank account ledger entry.    /// </summary>    /// <param name="BankAccountLedgerEntry">The bank account ledger entry record being modified.</param>    /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param>    [IntegrationEvent(false, false)]    local procedure OnCloseBankAccLedgEntryOnBeforeBankAccLedgEntryModify(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line")    begin    end;    /// <summary>    /// Event raised before modifying check ledger entry when closing bank account ledger entry.    /// </summary>    /// <param name="CheckLedgerEntry">The check ledger entry record being modified.</param>    /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param>    [IntegrationEvent(false, false)]    local procedure OnCloseBankAccLedgEntryOnBeforeCheckLedgEntryModify(var CheckLedgerEntry: Record "Check Ledger Entry"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line")    begin    end;    /// <summary>    /// Event raised after setting filters on bank account ledger entry when closing bank account ledger entry.    /// </summary>    /// <param name="BankAccountLedgerEntry">The bank account ledger entry record with filters applied.</param>    /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param>    [IntegrationEvent(false, false)]    local procedure OnCloseBankAccLedgEntryOnAfterBankAccLedgEntrySetFilters(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line")    begin    end;    /// <summary>    /// Event raised before handling payment application transfer during reconciliation posting.    /// </summary>    /// <param name="BankAccRecon">The bank account reconciliation record.</param>    /// <param name="IsHandled">Indicates whether the event has been handled.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeHandlePaymentApplicationTransfer(var BankAccRecon: Record "Bank Acc. Reconciliation"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Event raised after initializing the general journal line when posting payment applications.    /// </summary>    /// <param name="GenJournalLine">The general journal line record being initialized.</param>    /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param>    /// <param name="IsApplied">Indicates whether the payment has been applied.</param>    /// <param name="AppliedAmount">The total applied amount.</param>    /// <param name="PaymentLineAmount">The payment line amount.</param>    /// <param name="IsHandled">Indicates whether the event has been handled.</param>    [IntegrationEvent(false, false)]    local procedure OnPostPaymentApplicationsOnAfterInitGenJnlLine(var GenJournalLine: Record "Gen. Journal Line"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var IsApplied: Boolean; var AppliedAmount: Decimal; var PaymentLineAmount: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Event raised after posting a general journal line during payment application posting.    /// </summary>    /// <param name="GenJournalLine">The general journal line record that was posted.</param>    /// <param name="GenJnlPostLine">The general journal posting line codeunit instance.</param>    [IntegrationEvent(false, false)]    local procedure OnPostPaymentApplicationsOnAfterPostGenJnlLine(var GenJournalLine: Record "Gen. Journal Line"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")    begin    end;    /// <summary>    /// Event raised after setting filters on bank account ledger entry during payment application posting.    /// </summary>    /// <param name="BankAccountLedgerEntry">The bank account ledger entry record with filters applied.</param>    /// <param name="GenJournalLine">The general journal line record.</param>    [IntegrationEvent(false, false)]    local procedure OnPostPaymentApplicationsOnAfterBankAccountLedgerEntrySetFilters(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Event raised after checking that transaction is posted and reconciled during payment application posting.    /// </summary>    /// <param name="BankAccReconLine">The bank account reconciliation line record.</param>    /// <param name="AppliedAmount">The applied amount.</param>    /// <param name="SourceCode">The source code for the posting.</param>    [IntegrationEvent(false, false)]    local procedure OnPostPaymentApplicationsOnAfterTransactionPostedAndReconciledCheck(BankAccReconLine: Record "Bank Acc. Reconciliation Line"; var AppliedAmount: Decimal; SourceCode: Code[10])    begin    end;    /// <summary>    /// Event raised before validating apply requirements during payment application posting.    /// </summary>    /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param>    /// <param name="GenJournalLine">The general journal line record.</param>    /// <param name="AppliedAmount">The applied amount.</param>    [IntegrationEvent(false, false)]    local procedure OnPostPaymentApplicationsOnBeforeValidateApplyRequirements(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var GenJournalLine: Record "Gen. Journal Line"; AppliedAmount: Decimal)    begin    end;    /// <summary>    /// Event raised for account type case handling not covered by standard customer, vendor, or employee types.    /// </summary>    /// <param name="AppliedPaymentEntry">The applied payment entry record.</param>    /// <param name="GenJournalLine">The general journal line record.</param>    [IntegrationEvent(false, false)]    local procedure OnPostPaymentApplicationsOnAccountTypeCaseElse(var AppliedPaymentEntry: Record "Applied Payment Entry"; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Event raised after filtering bank account reconciliation lines during posting.    /// </summary>    /// <param name="BankAccReconLines">The bank account reconciliation lines record with filters applied.</param>    /// <param name="BankAccRecon">The bank account reconciliation record.</param>    [IntegrationEvent(false, false)]    local procedure OnPostAfterFilterBankAccRecLines(var BankAccReconLines: Record "Bank Acc. Reconciliation Line"; BankAccRecon: Record "Bank Acc. Reconciliation")    begin    end;    /// <summary>    /// Event raised before inserting bank account statement line when transferring to bank statement.    /// </summary>    /// <param name="BankAccStmtLine">The bank account statement line record being inserted.</param>    /// <param name="BankAccReconLine">The bank account reconciliation line record.</param>    [IntegrationEvent(false, false)]    local procedure OnTransferToBankStmtOnBeforeBankAccStmtLineInsert(var BankAccStmtLine: Record "Bank Account Statement Line"; BankAccReconLine: Record "Bank Acc. Reconciliation Line")    begin    end;    /// <summary>    /// Event raised before updating the bank account during reconciliation posting.    /// </summary>    /// <param name="BankAccRecon">The bank account reconciliation record.</param>    /// <param name="BankAccount">The bank account record being updated.</param>    /// <param name="IsHandled">Indicates whether the event has been handled.</param>    /// <param name="Amt">The amount for the update.</param>    /// <param name="PostedStamentNo">The posted statement number.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateBank(var BankAccRecon: Record "Bank Acc. Reconciliation"; var BankAccount: Record "Bank Account"; var IsHandled: Boolean; Amt: Decimal; PostedStamentNo: Code[20])    begin    end;    /// <summary>    /// Event raised before inserting posted payment reconciliation line when transferring to posted payment application.    /// </summary>    /// <param name="PostedPmtReconLine">The posted payment reconciliation line record being inserted.</param>    /// <param name="BankAccReconLine">The bank account reconciliation line record.</param>    [IntegrationEvent(false, false)]    local procedure OnTransferToPostPmtApplnOnBeforePostedPmtReconLineInsert(var PostedPmtReconLine: Record "Posted Payment Recon. Line"; BankAccReconLine: Record "Bank Acc. Reconciliation Line")    begin    end;    /// <summary>    /// Event raised before applying a customer ledger entry during bank reconciliation posting.    /// </summary>    /// <param name="CustLedgerEntry">The customer ledger entry record being applied.</param>    /// <param name="AppliedPaymentEntry">The applied payment entry record.</param>    /// <param name="BankAccount">The bank account record.</param>    /// <param name="AppliesToID">The applies-to identifier for the application.</param>    /// <param name="PostingDate">The posting date for the application.</param>    /// <param name="PmtDiscDueDate">The payment discount due date.</param>    /// <param name="PmtDiscToleranceDate">The payment discount tolerance date.</param>    /// <param name="RemPmtDiscPossible">The remaining payment discount possible amount.</param>    /// <param name="IsHandled">Indicates whether the event has been handled.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeApplyCustLedgEntry(var CustLedgerEntry: Record "Cust. Ledger Entry"; AppliedPaymentEntry: Record "Applied Payment Entry"; var BankAccount: Record "Bank Account"; AppliesToID: Code[50]; PostingDate: Date; PmtDiscDueDate: Date; PmtDiscToleranceDate: Date; RemPmtDiscPossible: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Event raised before applying a vendor ledger entry during bank reconciliation posting.    /// </summary>    /// <param name="VendLedgerEntry">The vendor ledger entry record being applied.</param>    /// <param name="AppliedPaymentEntry">The applied payment entry record.</param>    /// <param name="BankAccount">The bank account record.</param>    /// <param name="AppliesToID">The applies-to identifier for the application.</param>    /// <param name="PostingDate">The posting date for the application.</param>    /// <param name="PmtDiscDueDate">The payment discount due date.</param>    /// <param name="PmtDiscToleranceDate">The payment discount tolerance date.</param>    /// <param name="RemPmtDiscPossible">The remaining payment discount possible amount.</param>    /// <param name="ApplyVendLedgEntryHandled">Indicates whether the event has been handled.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeApplyVendLedgEntry(var VendLedgerEntry: Record "Vendor Ledger Entry"; AppliedPaymentEntry: Record "Applied Payment Entry"; var BankAccount: Record "Bank Account"; AppliesToID: Code[50]; PostingDate: Date; PmtDiscDueDate: Date; PmtDiscToleranceDate: Date; RemPmtDiscPossible: Decimal; var ApplyVendLedgEntryHandled: Boolean)    begin    end;}