Table 274 Bank Acc. Reconciliation Line

Base Application, Microsoft.Bank.Reconciliation

src/Layers/W1/BaseApp/Bank/Reconciliation/BankAccReconciliationLine.Table.al1,694 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.CRM.Team;using Microsoft.Finance.Dimension;using Microsoft.Finance.GeneralLedger.Account;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Ledger;using Microsoft.FixedAssets.FixedAsset;using Microsoft.Foundation.AuditCodes;using Microsoft.HumanResources.Employee;using Microsoft.Intercompany.Partner;using Microsoft.Purchases.Payables;using Microsoft.Purchases.Vendor;using Microsoft.Sales.Customer;using Microsoft.Sales.Receivables;using System.IO;using System.Utilities;/// <summary>/// Detailed bank statement lines for bank account reconciliation and payment application processes./// This table contains individual transaction records imported from bank statements or payment files,/// providing the line-item detail for reconciliation workflows. Each line represents a single bank/// transaction with amount, description, and matching information for application to ledger entries./// Supports both automated and manual matching scenarios with comprehensive tracking of applied amounts./// </summary>/// <remarks>/// Key features include statement import handling, automatic matching integration, manual application support,/// text-to-account mapping, difference management, and posting preparation. The table works closely with/// Applied Payment Entry records to track detailed payment applications and supports complex scenarios/// including partial payments, split transactions, and multi-currency reconciliation./// Integration points include bank statement import, matching algorithms, payment application rules,/// and general journal posting processes for finalizing reconciled transactions./// </remarks>table 274 "Bank Acc. Reconciliation Line"{    Caption = 'Bank Acc. Reconciliation Line';    Permissions = TableData "Data Exch. Field" = rimd;    DataClassification = CustomerContent;    fields    {        /// <summary>        /// Bank account number that this reconciliation line relates to.        /// Links the line to the specific bank account being reconciled and determines currency settings.        /// </summary>        field(1; "Bank Account No."; Code[20])        {            Caption = 'Bank Account No.';            TableRelation = "Bank Account";        }        /// <summary>        /// Statement number identifying the bank reconciliation or payment application batch.        /// Groups related statement lines under a single reconciliation session.        /// </summary>        field(2; "Statement No."; Code[20])        {            Caption = 'Statement No.';            TableRelation = "Bank Acc. Reconciliation"."Statement No." where("Bank Account No." = field("Bank Account No."));        }        /// <summary>        /// Sequential line number within the bank statement.        /// Provides unique identification and ordering of transactions within a statement.        /// </summary>        field(3; "Statement Line No."; Integer)        {            Caption = 'Statement Line No.';        }        /// <summary>        /// Document number associated with the bank transaction.        /// Contains reference numbers from bank statements such as check numbers or transaction IDs.        /// </summary>        field(4; "Document No."; Code[20])        {            Caption = 'Document No.';            ToolTip = 'Specifies a number of your choice that will appear on the reconciliation line.';        }        /// <summary>        /// Date when the bank transaction occurred.        /// Used for matching and validation during reconciliation processes.        /// </summary>        field(5; "Transaction Date"; Date)        {            Caption = 'Transaction Date';            ToolTip = 'Specifies the posting date of the bank account or check ledger entry on the reconciliation line when the Suggest Lines function is used.';        }        /// <summary>        /// Descriptive text for the bank transaction.        /// Contains transaction details imported from bank statements, used for matching and reporting.        /// </summary>        field(6; Description; Text[100])        {            Caption = 'Description';            ToolTip = 'Specifies a description for the transaction on the reconciliation line.';        }        /// <summary>        /// Amount of the bank statement transaction.        /// Represents the actual bank transaction amount to be reconciled against ledger entries.        /// </summary>        field(7; "Statement Amount"; Decimal)        {            AutoFormatExpression = GetCurrencyCode();            AutoFormatType = 1;            Caption = 'Statement Amount';            ToolTip = 'Specifies the amount that was paid into the bank account and then imported as a bank statement line represented by the journal line.';            trigger OnValidate()            begin                Difference := "Statement Amount" - "Applied Amount";            end;        }        /// <summary>        /// Calculated difference between statement amount and applied amount.        /// Shows remaining unreconciled amount that requires attention or posting to difference accounts.        /// </summary>        field(8; Difference; Decimal)        {            AutoFormatExpression = GetCurrencyCode();            AutoFormatType = 1;            BlankZero = true;            Caption = 'Difference';            ToolTip = 'Specifies the difference between the amount in the Statement Amount field and the amount in the Applied Amount field.';            trigger OnValidate()            begin                "Statement Amount" := "Applied Amount" + Difference;            end;        }        /// <summary>        /// Total amount applied to ledger entries for this statement line.        /// Calculated sum of all payment applications for this bank transaction.        /// </summary>        field(9; "Applied Amount"; Decimal)        {            AutoFormatExpression = GetCurrencyCode();            AutoFormatType = 1;            BlankZero = true;            Caption = 'Applied Amount';            ToolTip = 'Specifies the amount of the transaction on the reconciliation line that has been applied to a bank account or check ledger entry.';            Editable = false;            trigger OnValidate()            begin                Difference := "Statement Amount" - "Applied Amount";            end;        }        /// <summary>        /// Number of ledger entries applied to this statement line.        /// Provides quick reference to application complexity and enables drill-down to application details.        /// </summary>        field(11; "Applied Entries"; Integer)        {            Caption = 'Applied Entries';            ToolTip = 'Specifies whether the transaction on the bank''s statement has been applied to one or more bank account or check ledger entries.';            Editable = false;            trigger OnLookup()            begin                Rec.DisplayApplication();            end;        }        /// <summary>        /// Value date of the bank transaction as reported by the bank.        /// May differ from transaction date and affects interest calculations and reporting.        /// </summary>        field(12; "Value Date"; Date)        {            Caption = 'Value Date';            ToolTip = 'Specifies the value date of the transaction on the bank reconciliation line.';        }        /// <summary>        /// Indicates whether the statement line is ready for automatic payment application.        /// Used to control which lines participate in automated matching processes.        /// </summary>        field(13; "Ready for Application"; Boolean)        {            Caption = 'Ready for Application';        }        /// <summary>        /// Check number associated with the bank transaction.        /// Contains check reference for check-based payments imported from bank statements.        /// </summary>        field(14; "Check No."; Code[20])        {            Caption = 'Check No.';            ToolTip = 'Specifies the check number for the transaction on the reconciliation line.';        }        /// <summary>        /// Name of the related party (customer, vendor) for the transaction.        /// Used for automatic matching and payment application to appropriate accounts.        /// </summary>        field(15; "Related-Party Name"; Text[250])        {            Caption = 'Related-Party Name';            ToolTip = 'Specifies the name of the customer or vendor who made the payment that is represented by the journal line.';        }        /// <summary>        /// Additional transaction information from the bank statement.        /// Contains supplementary details that may assist in transaction identification and matching.        /// </summary>        field(16; "Additional Transaction Info"; Text[100])        {            Caption = 'Additional Transaction Info';            ToolTip = 'Specifies additional information on the bank statement line for the payment.';        }        /// <summary>        /// Data exchange entry number linking to the imported bank statement file.        /// References the specific import session for audit trail and troubleshooting.        /// </summary>        field(17; "Data Exch. Entry No."; Integer)        {            Caption = 'Data Exch. Entry No.';            Editable = false;            TableRelation = "Data Exch.";        }        /// <summary>        /// Line number within the data exchange entry.        /// Identifies the specific line in the imported file that created this statement line.        /// </summary>        field(18; "Data Exch. Line No."; Integer)        {            Caption = 'Data Exch. Line No.';            Editable = false;        }        /// <summary>        /// Specifies the type of the bank reconciliation statement for the line.        /// </summary>        field(20; "Statement Type"; Enum "Bank Acc. Rec. Stmt. Type")        {            Caption = 'Statement Type';        }        /// <summary>        /// Specifies the account type for the bank reconciliation line.        /// </summary>        field(21; "Account Type"; Enum "Gen. Journal Account Type")        {            Caption = 'Account Type';            ToolTip = 'Specifies the type of account that the payment application will be posted to when you post the payment reconciliation journal.';            trigger OnValidate()            begin                TestField("Applied Amount", 0);                if "Account Type" = "Account Type"::"IC Partner" then                    if not ConfirmManagement.GetResponse(ICPartnerAccountTypeQst, false) then begin                        "Account Type" := xRec."Account Type";                        exit;                    end;                if "Account Type" <> xRec."Account Type" then                    Validate("Account No.", '');            end;        }        /// <summary>        /// Specifies the account number for the bank reconciliation line.        /// </summary>        field(22; "Account No."; Code[20])        {            Caption = 'Account No.';            ToolTip = 'Specifies the account number that the payment application will be posted to when you post the payment reconciliation journal.';            TableRelation = if ("Account Type" = const("G/L Account")) "G/L Account" where("Account Type" = const(Posting),                                                                                          Blocked = const(false))            else            if ("Account Type" = const(Customer)) Customer            else            if ("Account Type" = const(Vendor)) Vendor            else            if ("Account Type" = const("Bank Account")) "Bank Account"            else            if ("Account Type" = const("Fixed Asset")) "Fixed Asset"            else            if ("Account Type" = const("IC Partner")) "IC Partner"            else            if ("Account Type" = const(Employee)) Employee;            trigger OnValidate()            begin                TestField("Applied Amount", 0);                CreateDimFromDefaultDim();            end;        }        /// <summary>        /// Specifies the transaction text from the bank statement.        /// </summary>        field(23; "Transaction Text"; Text[140])        {            Caption = 'Transaction Text';            ToolTip = 'Specifies the text that the customer or vendor entered on that payment transaction that is represented by the journal line.';            trigger OnValidate()            begin                if ("Statement Type" = "Statement Type"::"Payment Application") or (Description = '') then                    Description := CopyStr("Transaction Text", 1, MaxStrLen(Description));            end;        }        /// <summary>        /// Specifies the bank account number of the related party from the bank statement.        /// </summary>        field(24; "Related-Party Bank Acc. No."; Text[100])        {            Caption = 'Related-Party Bank Acc. No.';            ToolTip = 'Specifies the bank account number of the customer or vendor who made the payment.';        }        /// <summary>        /// Specifies the address of the related party from the bank statement.        /// </summary>        field(25; "Related-Party Address"; Text[100])        {            Caption = 'Related-Party Address';            ToolTip = 'Specifies the address of the customer or vendor who made the payment that is represented by the journal line.';        }        /// <summary>        /// Specifies the city of the related party from the bank statement.        /// </summary>        field(26; "Related-Party City"; Text[50])        {            Caption = 'Related-Party City';            ToolTip = 'Specifies the city name of the customer or vendor.';        }        /// <summary>        /// Specifies the payment reference number from the bank statement.        /// </summary>        field(27; "Payment Reference No."; Code[50])        {            Caption = 'Payment Reference';        }        /// <summary>        /// Specifies the first shortcut dimension code for the bank reconciliation line.        /// </summary>        field(31; "Shortcut Dimension 1 Code"; Code[20])        {            CaptionClass = '1,2,1';            Caption = 'Shortcut Dimension 1 Code';            ToolTip = 'Specifies the code for Shortcut Dimension 1, which is one of two global dimension codes that you set up on the General Ledger Setup page.';            TableRelation = "Dimension Value".Code where("Global Dimension No." = const(1),                                                          Blocked = const(false));            trigger OnValidate()            begin                Rec.ValidateShortcutDimCode(1, "Shortcut Dimension 1 Code");            end;        }        /// <summary>        /// Specifies the second shortcut dimension code for the bank reconciliation line.        /// </summary>        field(32; "Shortcut Dimension 2 Code"; Code[20])        {            CaptionClass = '1,2,2';            Caption = 'Shortcut Dimension 2 Code';            ToolTip = 'Specifies the code for Shortcut Dimension 2, which is one of two global dimension codes that you set up om the General Ledger Setup page.';            TableRelation = "Dimension Value".Code where("Global Dimension No." = const(2),                                                          Blocked = const(false));            trigger OnValidate()            begin                Rec.ValidateShortcutDimCode(2, "Shortcut Dimension 2 Code");            end;        }        /// <summary>        /// Specifies the confidence level of the automatic matching for the bank reconciliation line.        /// </summary>        field(50; "Match Confidence"; Enum "Bank Rec. Match Confidence")        {            CalcFormula = max("Applied Payment Entry"."Match Confidence" where("Statement Type" = field("Statement Type"),                                                                                "Bank Account No." = field("Bank Account No."),                                                                                "Statement No." = field("Statement No."),                                                                                "Statement Line No." = field("Statement Line No.")));            Caption = 'Match Confidence';            ToolTip = 'Specifies the quality of the automatic payment application on the journal line.';            Editable = false;            FieldClass = FlowField;            InitValue = "None";        }        /// <summary>        /// Specifies the quality score of the automatic matching for the bank reconciliation line.        /// </summary>        field(51; "Match Quality"; Integer)        {            CalcFormula = max("Applied Payment Entry".Quality where("Bank Account No." = field("Bank Account No."),                                                                     "Statement No." = field("Statement No."),                                                                     "Statement Line No." = field("Statement Line No."),                                                                     "Statement Type" = field("Statement Type")));            Caption = 'Match Quality';            Editable = false;            FieldClass = FlowField;        }        /// <summary>        /// Specifies the sorting order for the bank reconciliation line.        /// </summary>        field(60; "Sorting Order"; Integer)        {            Caption = 'Sorting Order';        }        /// <summary>        /// Specifies the parent line number for grouped bank reconciliation lines.        /// </summary>        field(61; "Parent Line No."; Integer)        {            Caption = 'Parent Line No.';            Editable = false;        }        /// <summary>        /// Specifies the unique transaction identifier from the bank statement.        /// </summary>        field(70; "Transaction ID"; Text[50])        {            Caption = 'Transaction ID';            ToolTip = 'Specifies the ID of the imported bank transaction.';        }        /// <summary>        /// Specifies the ID of the dimension set for the bank reconciliation line.        /// </summary>        field(480; "Dimension Set ID"; Integer)        {            Caption = 'Dimension Set ID';            Editable = false;            TableRelation = "Dimension Set Entry";            trigger OnLookup()            begin                Rec.ShowDimensions();            end;            trigger OnValidate()            begin                DimMgt.UpdateGlobalDimFromDimSetID("Dimension Set ID", "Shortcut Dimension 1 Code", "Shortcut Dimension 2 Code");            end;        }    }    keys    {        key(Key1; "Statement Type", "Bank Account No.", "Statement No.", "Statement Line No.")        {            Clustered = true;        }        key(Key2; "Account Type", "Statement Amount")        {        }    }    fieldgroups    {    }    trigger OnDelete()    begin        RemoveApplication();        ClearDataExchEntries();        RemoveAppliedPaymentEntries();        DeletePaymentMatchingDetails();        UpdateParentLineStatementAmount();        if Find() then;    end;    trigger OnInsert()    begin        BankAccRecon.Get("Statement Type", "Bank Account No.", "Statement No.");        "Applied Entries" := 0;        Validate("Applied Amount", 0);    end;    trigger OnModify()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeOnModify(Rec, IsHandled);        if IsHandled then            exit;        if xRec."Statement Amount" <> "Statement Amount" then            RemoveApplication();    end;    trigger OnRename()    begin        Error(YouCannotRenameErr, TableCaption);    end;    var        BankAccSetStmtNo: Codeunit "Bank Acc. Entry Set Recon.-No.";        DimMgt: Codeunit DimensionManagement;        ConfirmManagement: Codeunit "Confirm Management";        YouCannotRenameErr: Label 'You cannot rename a %1.', Comment = '%1 - Table name';        AmountWithinToleranceRangeTok: Label '>=%1&<=%2', Locked = true;        AmountOustideToleranceRangeTok: Label '<%1|>%2', Locked = true;        TransactionAmountMustNotBeZeroErr: Label 'The Transaction Amount field must have a value that is not 0.';        CreditTheAccountQst: Label 'The remaining amount to apply is %2.\\Do you want to create a new payment application line that will debit or credit %1 with the remaining amount when you post the payment?', Comment = '%1 is the account name, %2 is the amount that is not applied (there is filed on the page named Remaining Amount To Apply)';        ExcessiveAmountErr: Label 'The remaining amount to apply is %1.', Comment = '%1 is the amount that is not applied (there is filed on the page named Remaining Amount To Apply)';        ImportPostedTransactionsQst: Label 'The bank statement contains payments that are already applied, but the related bank account ledger entries are not closed.\\Do you want to include these payments in the import?';        ICPartnerAccountTypeQst: Label 'The resulting entry will be of type IC Transaction, but no Intercompany Outbox transaction will be created. \\Do you want to use the IC Partner account type anyway?';        AppliedEntriesFilterLbl: Label '|%1', Locked = true;        MatchedAutomaticallyFilterLbl: Label '=%1|%2|%3|%4', Locked = true;        NotAppliedTxt: Label 'Not applied';        MatchedAutomaticallyTxt: Label 'Matched Automatically';        MatchedFromTextMappingRulesTxt: Label 'Matched - Text-To-Account Mapping';        AppliedManuallyStatusTxt: Label 'Applied Manually';        ReviewedStatusTxt: Label 'Application Reviewed';        PaymentRecJournalFeatureNameTelemetryTxt: Label 'Payment Reconciliation', Locked = true;    protected var        BankAccLedgEntry: Record "Bank Account Ledger Entry";        CheckLedgEntry: Record "Check Ledger Entry";        BankAccRecon: Record "Bank Acc. Reconciliation";    internal procedure GetPaymentRecJournalTelemetryFeatureName(): Text    begin        exit(PaymentRecJournalFeatureNameTelemetryTxt);    end;    /// <summary>    /// Opens the payment application interface to display and manage applications for this reconciliation line.    /// For bank reconciliation, shows bank account ledger entries; for payment application, shows detailed payment applications.    /// Provides interactive interface for reviewing, modifying, or removing payment applications.    /// </summary>    procedure DisplayApplication()    var        PaymentApplication: Page "Payment Application";    begin        case "Statement Type" of            "Statement Type"::"Bank Reconciliation":                begin                    BankAccLedgEntry.Reset();                    BankAccLedgEntry.SetCurrentKey("Bank Account No.", Open);                    BankAccLedgEntry.SetRange("Bank Account No.", "Bank Account No.");                    BankAccLedgEntry.SetRange(Open, true);                    BankAccLedgEntry.SetRange(                        "Statement Status", BankAccLedgEntry."Statement Status"::"Bank Acc. Entry Applied");                    BankAccLedgEntry.SetRange("Statement No.", "Statement No.");                    BankAccLedgEntry.SetRange("Statement Line No.", "Statement Line No.");                    OnDisplayApplicationOnAfterBankAccLedgEntrySetFilters(Rec, BankAccLedgEntry);                    PAGE.Run(0, BankAccLedgEntry);                end;            "Statement Type"::"Payment Application":                begin                    if "Statement Amount" = 0 then                        Error(TransactionAmountMustNotBeZeroErr);                    PaymentApplication.SetBankAccReconcLine(Rec);                    OnDisplayApplicationOnAfterSetBankAccReconcLine(PaymentApplication);                    PaymentApplication.RunModal();                end;        end;    end;    procedure TransferFromPostedPaymentReconLine(PostedPaymentReconLine: Record "Posted Payment Recon. Line")    begin        Rec."Bank Account No." := PostedPaymentReconLine."Bank Account No.";        Rec."Statement No." := PostedPaymentReconLine."Statement No.";        Rec."Statement Line No." := PostedPaymentReconLine."Statement Line No.";        Rec."Document No." := PostedPaymentReconLine."Document No.";        Rec."Transaction Date" := PostedPaymentReconLine."Transaction Date";        Rec.Description := PostedPaymentReconLine.Description;        Rec."Statement Amount" := PostedPaymentReconLine."Statement Amount";        Rec.Difference := PostedPaymentReconLine.Difference;        Rec."Applied Amount" := PostedPaymentReconLine."Applied Amount";        Rec."Applied Entries" := PostedPaymentReconLine."Applied Entries";        Rec."Value Date" := PostedPaymentReconLine."Value Date";        Rec."Check No." := PostedPaymentReconLine."Check No.";        Rec."Related-Party Name" := PostedPaymentReconLine."Related-Party Name";        Rec."Additional Transaction Info" := PostedPaymentReconLine."Additional Transaction Info";        Rec."Data Exch. Entry No." := PostedPaymentReconLine."Data Exch. Entry No.";        Rec."Data Exch. Line No." := PostedPaymentReconLine."Data Exch. Line No.";        Rec."Statement Type" := Rec."Statement Type"::"Payment Application";        Rec."Account Type" := PostedPaymentReconLine."Account Type";        Rec."Account No." := PostedPaymentReconLine."Account No.";        Rec."Transaction Text" := PostedPaymentReconLine.Description;        Rec."Transaction ID" := CopyStr(PostedPaymentReconLine."Transaction ID", 1, MaxStrLen(Rec."Transaction ID"));        OnAfterTransferFromPostedPaymentReconLine(Rec, PostedPaymentReconLine);    end;    procedure GetPaymentFile(var DataExchField: Record "Data Exch. Field"): Boolean    begin        if not DataExchField.ReadPermission() then            exit(false);        DataExchField.SetRange("Data Exch. No.", "Data Exch. Entry No.");        DataExchField.SetRange("Line No.", "Data Exch. Line No.");        exit(DataExchField.FindFirst());    end;    /// <summary>    /// Retrieves the currency code associated with the bank account for this reconciliation line.    /// Optimizes performance by caching the bank account record when possible.    /// </summary>    /// <returns>Currency code of the associated bank account; empty string if bank account not found or uses local currency.</returns>    procedure GetCurrencyCode(): Code[10]    var        BankAccount: Record "Bank Account";    begin        if "Bank Account No." = BankAccount."No." then            exit(BankAccount."Currency Code");        if BankAccount.Get("Bank Account No.") then            exit(BankAccount."Currency Code");        exit('');    end;    procedure GetStyle() Result: Text    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetStyle(Rec, Result, IsHandled);        if IsHandled then            exit(Result);        if "Applied Entries" <> 0 then            exit('Favorable');        exit('');    end;    /// <summary>    /// Clears data exchange entries and related import data for this reconciliation line.    /// Removes data exchange field records and updates related reconciliation lines that share the same data exchange entry.    /// Used during cleanup operations when removing or modifying imported statement data.    /// </summary>    procedure ClearDataExchEntries()    var        DataExchField: Record "Data Exch. Field";        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";    begin        DataExchField.DeleteRelatedRecords("Data Exch. Entry No.", "Data Exch. Line No.");        BankAccReconciliationLine.SetRange("Statement Type", "Statement Type");        BankAccReconciliationLine.SetRange("Bank Account No.", "Bank Account No.");        BankAccReconciliationLine.SetRange("Statement No.", "Statement No.");        BankAccReconciliationLine.SetRange("Data Exch. Entry No.", "Data Exch. Entry No.");        BankAccReconciliationLine.SetFilter("Statement Line No.", '<>%1', "Statement Line No.");        if BankAccReconciliationLine.IsEmpty() then            DataExchField.DeleteRelatedRecords("Data Exch. Entry No.", 0);    end;    procedure ShowDimensions()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeShowDimensions(Rec, IsHandled);        if IsHandled then            exit;        "Dimension Set ID" :=          DimMgt.EditDimensionSet("Dimension Set ID", StrSubstNo('%1 %2 %3', TableCaption(), "Statement No.", "Statement Line No."));        DimMgt.UpdateGlobalDimFromDimSetID("Dimension Set ID", "Shortcut Dimension 1 Code", "Shortcut Dimension 2 Code");        OnAfterShowDimensions(Rec);    end;    procedure CreateDim(DefaultDimSource: List of [Dictionary of [Integer, Code[20]]])    var        SourceCodeSetup: Record "Source Code Setup";        BankAccReconciliation: Record "Bank Acc. Reconciliation";    begin        SourceCodeSetup.Get();        "Shortcut Dimension 1 Code" := '';        "Shortcut Dimension 2 Code" := '';        BankAccReconciliation.Get(Rec."Statement Type", Rec."Bank Account No.", Rec."Statement No.");        "Dimension Set ID" :=          DimMgt.GetRecDefaultDimID(            Rec, CurrFieldNo, DefaultDimSource, SourceCodeSetup."Payment Reconciliation Journal",            "Shortcut Dimension 1 Code", "Shortcut Dimension 2 Code", BankAccReconciliation."Dimension Set ID", DATABASE::"Bank Account");        DimMgt.UpdateGlobalDimFromDimSetID("Dimension Set ID", "Shortcut Dimension 1 Code", "Shortcut Dimension 2 Code");        OnAfterCreateDim(Rec, DefaultDimSource);    end;    procedure SetUpNewLine()    begin        "Transaction Date" := WorkDate();        "Match Confidence" := "Match Confidence"::None;        "Document No." := '';        OnAfterSetUpNewLine(Rec, xRec);    end;    procedure ValidateShortcutDimCode(FieldNumber: Integer; var ShortcutDimCode: Code[20])    begin        OnBeforeValidateShortcutDimCode(Rec, xRec, FieldNumber, ShortcutDimCode);        DimMgt.ValidateShortcutDimValues(FieldNumber, ShortcutDimCode, "Dimension Set ID");        OnAfterValidateShortcutDimCode(Rec, xRec, FieldNumber, ShortcutDimCode);    end;    procedure ShowShortcutDimCode(var ShortcutDimCode: array[8] of Code[20])    begin        DimMgt.GetShortcutDimensions(Rec."Dimension Set ID", ShortcutDimCode);    end;    procedure AcceptAppliedPaymentEntriesSelectedLines()    begin        if FindSet() then            repeat                AcceptApplication();            until Next() = 0;    end;    procedure RejectAppliedPaymentEntriesSelectedLines()    begin        if FindSet() then            repeat                RejectAppliedPayment();            until Next() = 0;    end;    procedure RejectAppliedPayment()    begin        RemoveAppliedPaymentEntries();        DeletePaymentMatchingDetails();    end;    procedure AcceptApplication()    var        AppliedPaymentEntry: Record "Applied Payment Entry";    begin        // For customer payments, the applied amount is positive, so positive difference means excessive amount.        // For vendor payments, the applied amount is negative, so negative difference means excessive amount.        // If "Applied Amount" and Difference have the same sign, then this is an overpayment situation.        // Two non-zero numbers have the same sign if and only if their product is a positive number.        if Difference * "Applied Amount" > 0 then begin            if "Account Type" = "Account Type"::"Bank Account" then                Error(ExcessiveAmountErr, Difference);            SetAppliedPaymentEntryFromRec(AppliedPaymentEntry);            if not AppliedPaymentEntry.Find() then begin                if not Confirm(StrSubstNo(CreditTheAccountQst, GetAppliedToName(), Difference)) then                    exit;                TransferRemainingAmountToAccount();            end;        end;        AppliedPaymentEntry.FilterAppliedPmtEntry(Rec);        AppliedPaymentEntry.ModifyAll("Match Confidence", "Match Confidence"::Accepted);    end;    procedure FilterManyToOneMatches(var BankAccRecMatchBuffer: Record "Bank Acc. Rec. Match Buffer")    begin        BankAccRecMatchBuffer.SetRange("Statement No.", Rec."Statement No.");        BankAccRecMatchBuffer.SetRange("Bank Account No.", Rec."Bank Account No.");        BankAccRecMatchBuffer.SetRange("Statement Line No.", Rec."Statement Line No.");    end;    protected procedure RemoveApplication()    var        BankAccRecMatchBuffer: Record "Bank Acc. Rec. Match Buffer";        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";        ManyToOneBLEFound: Boolean;    begin        if "Statement Type" <> "Statement Type"::"Bank Reconciliation" then            exit;        FilterManyToOneMatches(BankAccRecMatchBuffer);        if BankAccRecMatchBuffer.FindFirst() then begin            BankAccLedgEntry.Reset();            BankAccLedgEntry.SetRange("Entry No.", BankAccRecMatchBuffer."Ledger Entry No.");            BankAccLedgEntry.SetRange(Open, true);            BankAccLedgEntry.SetRange(                "Statement Status", BankAccLedgEntry."Statement Status"::"Bank Acc. Entry Applied");            if BankAccLedgEntry.FindFirst() then begin                ManyToOneBLEFound := true;                BankAccSetStmtNo.RemoveReconNo(BankAccLedgEntry, Rec, false);                BankAccRecMatchBuffer.Delete();            end;        end;        BankAccRecMatchBuffer.Reset();        BankAccRecMatchBuffer.SetRange("Ledger Entry No.", BankAccLedgEntry."Entry No.");        BankAccRecMatchBuffer.SetRange("Statement No.", Rec."Statement No.");        BankAccRecMatchBuffer.SetRange("Bank Account No.", Rec."Bank Account No.");        if (BankAccRecMatchBuffer.FindSet()) and (ManyToOneBLEFound) then begin            repeat                BankAccReconciliationLine.SetRange("Statement Line No.", BankAccRecMatchBuffer."Statement Line No.");                BankAccReconciliationLine.SetRange("Statement No.", BankAccRecMatchBuffer."Statement No.");                BankAccReconciliationLine.SetRange("Bank Account No.", BankAccRecMatchBuffer."Bank Account No.");                if BankAccReconciliationLine.FindFirst() then begin                    BankAccReconciliationLine."Applied Entries" := 0;                    BankAccReconciliationLine.Validate("Applied Amount", 0);                    BankAccReconciliationLine.Modify();                end;            until BankAccRecMatchBuffer.Next() = 0;            BankAccRecMatchBuffer.DeleteAll();        end;        BankAccLedgEntry.Reset();        BankAccLedgEntry.SetCurrentKey("Bank Account No.", Open);        BankAccLedgEntry.SetRange("Bank Account No.", "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.", "Statement No.");        BankAccLedgEntry.SetRange("Statement Line No.", "Statement Line No.");        OnRemoveApplicationOnAfterBankAccLedgEntrySetFilters(Rec, BankAccLedgEntry);        BankAccLedgEntry.LockTable();        CheckLedgEntry.LockTable();        if BankAccLedgEntry.Find('-') then            repeat                BankAccSetStmtNo.RemoveReconNo(BankAccLedgEntry, Rec, true);            until BankAccLedgEntry.Next() = 0;        "Applied Entries" := 0;        Validate("Applied Amount", 0);        Modify();    end;    procedure SetManualApplication()    var        AppliedPaymentEntry: Record "Applied Payment Entry";    begin        AppliedPaymentEntry.FilterAppliedPmtEntry(Rec);        AppliedPaymentEntry.ModifyAll("Match Confidence", "Match Confidence"::Manual)    end;    local procedure RemoveAppliedPaymentEntries()    var        AppliedPaymentEntry: Record "Applied Payment Entry";    begin        Validate("Applied Amount", 0);        Validate("Applied Entries", 0);        Validate("Account No.", '');        Modify(true);        AppliedPaymentEntry.FilterAppliedPmtEntry(Rec);        AppliedPaymentEntry.DeleteAll(true);        OnAfterRemoveAppliedPaymentEntries(Rec);    end;    local procedure DeletePaymentMatchingDetails()    var        PaymentMatchingDetails: Record "Payment Matching Details";    begin        PaymentMatchingDetails.SetRange("Statement Type", "Statement Type");        PaymentMatchingDetails.SetRange("Bank Account No.", "Bank Account No.");        PaymentMatchingDetails.SetRange("Statement No.", "Statement No.");        PaymentMatchingDetails.SetRange("Statement Line No.", "Statement Line No.");        PaymentMatchingDetails.DeleteAll(true);    end;    procedure GetAppliedEntryAccountName(AppliedToEntryNo: Integer): Text    var        AccountType: Option;        AccountNo: Code[20];    begin        AccountType := GetAppliedEntryAccountType(AppliedToEntryNo);        AccountNo := GetAppliedEntryAccountNo(AppliedToEntryNo);        exit(GetAccountName(AccountType, AccountNo));    end;    procedure GetAppliedToName(): Text    var        AccountType: Option;        AccountNo: Code[20];    begin        AccountType := GetAppliedToAccountType();        AccountNo := GetAppliedToAccountNo();        exit(GetAccountName(AccountType, AccountNo));    end;    procedure GetAppliedEntryAccountType(AppliedToEntryNo: Integer): Integer    var        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";    begin        if "Account Type" = "Account Type"::"Bank Account" then            if BankAccountLedgerEntry.Get(AppliedToEntryNo) then                exit(BankAccountLedgerEntry."Bal. Account Type".AsInteger());        exit("Account Type".AsInteger());    end;    procedure GetAppliedToAccountType(): Integer    var        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";    begin        if "Account Type" = "Account Type"::"Bank Account" then            if BankAccountLedgerEntry.Get(GetFirstAppliedToEntryNo()) then                exit(BankAccountLedgerEntry."Bal. Account Type".AsInteger());        exit("Account Type".AsInteger());    end;    procedure GetAppliedEntryAccountNo(AppliedToEntryNo: Integer) AccountNo: Code[20]    var        CustLedgerEntry: Record "Cust. Ledger Entry";        VendorLedgerEntry: Record "Vendor Ledger Entry";        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";    begin        case "Account Type" of            "Account Type"::Customer:                if CustLedgerEntry.Get(AppliedToEntryNo) then                    exit(CustLedgerEntry."Customer No.");            "Account Type"::Vendor:                if VendorLedgerEntry.Get(AppliedToEntryNo) then                    exit(VendorLedgerEntry."Vendor No.");            "Account Type"::"Bank Account":                if BankAccountLedgerEntry.Get(AppliedToEntryNo) then                    exit(BankAccountLedgerEntry."Bal. Account No.");        end;        AccountNo := "Account No.";        OnAfterGetAppliedEntryAccountNo(Rec, AppliedToEntryNo, AccountNo);    end;    procedure GetAppliedToAccountNo(): Code[20]    var        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";    begin        if "Account Type" = "Account Type"::"Bank Account" then            if BankAccountLedgerEntry.Get(GetFirstAppliedToEntryNo()) then                exit(BankAccountLedgerEntry."Bal. Account No.");        exit("Account No.")    end;    local procedure GetAccountName(AccountType: Option; AccountNo: Code[20]) Name: Text    var        Customer: Record Customer;        Vendor: Record Vendor;        Employee: Record Employee;        GLAccount: Record "G/L Account";        BankAccount: Record "Bank Account";    begin        case AccountType of            "Account Type"::Customer.AsInteger():                if Customer.Get(AccountNo) then                    Name := Customer.Name;            "Account Type"::Vendor.AsInteger():                if Vendor.Get(AccountNo) then                    Name := Vendor.Name;            "Account Type"::Employee.AsInteger():                if Employee.Get(AccountNo) then                    Name := Employee.FullName();            "Account Type"::"G/L Account".AsInteger():                if GLAccount.Get(AccountNo) then                    Name := GLAccount.Name;            "Account Type"::"Bank Account".AsInteger():                if BankAccount.Get(AccountNo) then                    Name := BankAccount.Name;        end;        OnAfterGetAccountName(AccountType, AccountNo, Name);    end;    local procedure SetAppliedPaymentEntryFromRec(var AppliedPaymentEntry: Record "Applied Payment Entry")    begin        AppliedPaymentEntry.TransferFromBankAccReconLine(Rec);        AppliedPaymentEntry."Account Type" := Enum::"Gen. Journal Account Type".FromInteger(GetAppliedToAccountType());        AppliedPaymentEntry."Account No." := GetAppliedToAccountNo();    end;    procedure AppliedEntryAccountDrillDown(AppliedEntryNo: Integer)    var        AccountType: Option;        AccountNo: Code[20];    begin        AccountType := GetAppliedEntryAccountType(AppliedEntryNo);        AccountNo := GetAppliedEntryAccountNo(AppliedEntryNo);        OpenAccountPage(AccountType, AccountNo);    end;    procedure AppliedToDrillDown()    var        AccountType: Option;        AccountNo: Code[20];    begin        AccountType := GetAppliedToAccountType();        AccountNo := GetAppliedToAccountNo();        OpenAccountPage(AccountType, AccountNo);    end;    procedure OpenAccountPage(AccountType: Option; AccountNo: Code[20])    var        Customer: Record Customer;        Vendor: Record Vendor;        GLAccount: Record "G/L Account";        BankAccount: Record "Bank Account";    begin        case AccountType of            "Account Type"::Customer.AsInteger():                begin                    Customer.Get(AccountNo);                    PAGE.Run(PAGE::"Customer Card", Customer);                end;            "Account Type"::Vendor.AsInteger():                begin                    Vendor.Get(AccountNo);                    PAGE.Run(PAGE::"Vendor Card", Vendor);                end;            "Account Type"::"G/L Account".AsInteger():                begin                    GLAccount.Get(AccountNo);                    PAGE.Run(PAGE::"G/L Account Card", GLAccount);                end;            "Account Type"::"Bank Account".AsInteger():                begin                    BankAccount.Get(AccountNo);                    PAGE.Run(PAGE::"Bank Account Card", BankAccount);                end;        end;        OnAfterOpenAccountPage(AccountType, AccountNo);    end;    procedure DrillDownOnNoOfLedgerEntriesWithinAmountTolerance()    begin        DrillDownOnNoOfLedgerEntriesBasedOnAmount(AmountWithinToleranceRangeTok);    end;    procedure DrillDownOnNoOfLedgerEntriesOutsideOfAmountTolerance()    begin        DrillDownOnNoOfLedgerEntriesBasedOnAmount(AmountOustideToleranceRangeTok);    end;    local procedure DrillDownOnNoOfLedgerEntriesBasedOnAmount(AmountFilter: Text)    var        CustLedgerEntry: Record "Cust. Ledger Entry";        VendorLedgerEntry: Record "Vendor Ledger Entry";        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        MinAmount: Decimal;        MaxAmount: Decimal;    begin        GetAmountRangeForTolerance(MinAmount, MaxAmount);        case "Account Type" of            "Account Type"::Customer:                begin                    GetCustomerLedgerEntriesInAmountRange(CustLedgerEntry, "Account No.", AmountFilter, MinAmount, MaxAmount);                    PAGE.Run(PAGE::"Customer Ledger Entries", CustLedgerEntry);                end;            "Account Type"::Vendor:                begin                    GetVendorLedgerEntriesInAmountRange(VendorLedgerEntry, "Account No.", AmountFilter, MinAmount, MaxAmount);                    PAGE.Run(PAGE::"Vendor Ledger Entries", VendorLedgerEntry);                end;            "Account Type"::"Bank Account":                begin                    GetBankAccountLedgerEntriesInAmountRange(BankAccountLedgerEntry, AmountFilter, MinAmount, MaxAmount);                    PAGE.Run(PAGE::"Bank Account Ledger Entries", BankAccountLedgerEntry);                end;        end;        OnAfterDrillDownOnNoOfLedgerEntriesBasedOnAmount(Rec, AmountFilter);    end;    local procedure GetCustomerLedgerEntriesInAmountRange(var CustLedgerEntry: Record "Cust. Ledger Entry"; AccountNo: Code[20]; AmountFilter: Text; MinAmount: Decimal; MaxAmount: Decimal): Integer    var        BankAccount: Record "Bank Account";        Result: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetCustomerLedgerEntriesInAmountRange(Rec, CustLedgerEntry, AccountNo, AmountFilter, MinAmount, MaxAmount, Result, IsHandled);        if IsHandled then            exit(Result);        CustLedgerEntry.SetAutoCalcFields("Remaining Amount", "Remaining Amt. (LCY)");        BankAccount.Get("Bank Account No.");        GetApplicableCustomerLedgerEntries(CustLedgerEntry, BankAccount."Currency Code", AccountNo);        if BankAccount.IsInLocalCurrency() then            CustLedgerEntry.SetFilter("Remaining Amt. (LCY)", AmountFilter, MinAmount, MaxAmount)        else            CustLedgerEntry.SetFilter("Remaining Amount", AmountFilter, MinAmount, MaxAmount);        exit(CustLedgerEntry.Count);    end;    local procedure GetVendorLedgerEntriesInAmountRange(var VendorLedgerEntry: Record "Vendor Ledger Entry"; AccountNo: Code[20]; AmountFilter: Text; MinAmount: Decimal; MaxAmount: Decimal): Integer    var        BankAccount: Record "Bank Account";        Result: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetVendorLedgerEntriesInAmountRange(Rec, VendorLedgerEntry, AccountNo, AmountFilter, MinAmount, MaxAmount, Result, IsHandled);        if IsHandled then            exit(Result);        VendorLedgerEntry.SetAutoCalcFields("Remaining Amount", "Remaining Amt. (LCY)");        BankAccount.Get("Bank Account No.");        GetApplicableVendorLedgerEntries(VendorLedgerEntry, BankAccount."Currency Code", AccountNo);        if BankAccount.IsInLocalCurrency() then            VendorLedgerEntry.SetFilter("Remaining Amt. (LCY)", AmountFilter, MinAmount, MaxAmount)        else            VendorLedgerEntry.SetFilter("Remaining Amount", AmountFilter, MinAmount, MaxAmount);        exit(VendorLedgerEntry.Count);    end;    local procedure GetBankAccountLedgerEntriesInAmountRange(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; AmountFilter: Text; MinAmount: Decimal; MaxAmount: Decimal): Integer    var        BankAccount: Record "Bank Account";    begin        BankAccount.Get("Bank Account No.");        GetApplicableBankAccountLedgerEntries(BankAccountLedgerEntry, BankAccount."Currency Code", "Bank Account No.");        BankAccountLedgerEntry.SetFilter("Remaining Amount", AmountFilter, MinAmount, MaxAmount);        exit(BankAccountLedgerEntry.Count);    end;    local procedure GetApplicableCustomerLedgerEntries(var CustLedgerEntry: Record "Cust. Ledger Entry"; CurrencyCode: Code[10]; AccountNo: Code[20])    begin        CustLedgerEntry.SetRange(Open, true);        CustLedgerEntry.SetRange("Applies-to ID", '');        CustLedgerEntry.SetFilter("Document Type", '<>%1&<>%2',          CustLedgerEntry."Document Type"::Payment,          CustLedgerEntry."Document Type"::Refund);        if CurrencyCode <> '' then            CustLedgerEntry.SetRange("Currency Code", CurrencyCode);        if AccountNo <> '' then            CustLedgerEntry.SetFilter("Customer No.", AccountNo);    end;    local procedure GetApplicableVendorLedgerEntries(var VendorLedgerEntry: Record "Vendor Ledger Entry"; CurrencyCode: Code[10]; AccountNo: Code[20])    begin        VendorLedgerEntry.SetRange(Open, true);        VendorLedgerEntry.SetRange("Applies-to ID", '');        VendorLedgerEntry.SetFilter("Document Type", '<>%1&<>%2',          VendorLedgerEntry."Document Type"::Payment,          VendorLedgerEntry."Document Type"::Refund);        if CurrencyCode <> '' then            VendorLedgerEntry.SetRange("Currency Code", CurrencyCode);        if AccountNo <> '' then            VendorLedgerEntry.SetFilter("Vendor No.", AccountNo);    end;    local procedure GetApplicableBankAccountLedgerEntries(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; CurrencyCode: Code[10]; AccountNo: Code[20])    begin        BankAccountLedgerEntry.SetRange(Open, true);        if CurrencyCode <> '' then            BankAccountLedgerEntry.SetRange("Currency Code", CurrencyCode);        if AccountNo <> '' then            BankAccountLedgerEntry.SetRange("Bank Account No.", AccountNo);    end;    procedure FilterBankRecLinesByDate(BankAccReconciliation: Record "Bank Acc. Reconciliation"; Overwrite: Boolean)    begin        FilterBankRecLines(BankAccReconciliation, Overwrite);        // Records sorted by transaction date to optimize matching        Rec.SetCurrentKey("Transaction Date");        Rec.SetAscending("Transaction Date", true);    end;    procedure FilterBankRecLines(BankAccReconciliation: Record "Bank Acc. Reconciliation"; Overwrite: Boolean)    begin        Rec.Reset();        Rec.SetRange("Statement Type", BankAccReconciliation."Statement Type");        Rec.SetRange("Bank Account No.", BankAccReconciliation."Bank Account No.");        Rec.SetRange("Statement No.", BankAccReconciliation."Statement No.");        if not Overwrite then            Rec.SetRange("Applied Entries", 0);        OnAfterFilterBankRecLines(Rec, BankAccReconciliation);    end;    procedure FilterBankRecLines(BankAccReconciliation: Record "Bank Acc. Reconciliation")    begin        FilterBankRecLines(BankAccReconciliation, true);    end;    procedure LinesExist(BankAccRecon: Record "Bank Acc. Reconciliation"): Boolean    begin        FilterBankRecLines(BankAccRecon);        exit(FindSet());    end;    procedure GetAppliedToDocumentNo(SeparatorTxt: Text): Text    var        ApplyType: Option "Document No.","Entry No.";    begin        exit(GetAppliedNo(ApplyType::"Document No.", SeparatorTxt));    end;    procedure GetAppliedToDocumentNo(): Text    begin        exit(GetAppliedToDocumentNo(', '));    end;    procedure GetAppliedToEntryNo(): Text    var        ApplyType: Option "Document No.","Entry No.";    begin        exit(GetAppliedNo(ApplyType::"Entry No.", ', '));    end;    procedure GetAppliedToEntryFilter(): Text    var        ApplyType: Option "Document No.","Entry No.";    begin        exit(GetAppliedNo(ApplyType::"Entry No.", '|'));    end;    local procedure GetFirstAppliedToEntryNo(): Integer    var        AppliedEntryNumbers: Text;        AppliedToEntryNo: Integer;    begin        AppliedEntryNumbers := GetAppliedToEntryNo();        if AppliedEntryNumbers = '' then            exit(0);        Evaluate(AppliedToEntryNo, SelectStr(1, AppliedEntryNumbers));        exit(AppliedToEntryNo);    end;    local procedure GetAppliedNo(ApplyType: Option "Document No.","Entry No."; SeparatorText: Text): Text    var        AppliedPaymentEntry: Record "Applied Payment Entry";        AppliedNumbers: Text;    begin        AppliedPaymentEntry.SetRange("Statement Type", "Statement Type");        AppliedPaymentEntry.SetRange("Bank Account No.", "Bank Account No.");        AppliedPaymentEntry.SetRange("Statement No.", "Statement No.");        AppliedPaymentEntry.SetRange("Statement Line No.", "Statement Line No.");        AppliedNumbers := '';        if AppliedPaymentEntry.FindSet() then            repeat                if ApplyType = ApplyType::"Document No." then begin                    if AppliedPaymentEntry."Document No." <> '' then                        if AppliedNumbers = '' then                            AppliedNumbers := AppliedPaymentEntry."Document No."                        else                            AppliedNumbers := AppliedNumbers + SeparatorText + AppliedPaymentEntry."Document No.";                end else                    if AppliedPaymentEntry."Applies-to Entry No." <> 0 then                        if AppliedNumbers = '' then                            AppliedNumbers := Format(AppliedPaymentEntry."Applies-to Entry No.")                        else                            AppliedNumbers := AppliedNumbers + SeparatorText + Format(AppliedPaymentEntry."Applies-to Entry No.");            until AppliedPaymentEntry.Next() = 0;        exit(AppliedNumbers);    end;    procedure ShowAppliedToEntries()    var        AppliedPaymentEntry: Record "Applied Payment Entry";        CustLedgEntry: Record "Cust. Ledger Entry";        VendLedgEntry: Record "Vendor Ledger Entry";        AppliedBankAccLedgEntry: Record "Bank Account Ledger Entry";        GLEntry: Record "G/L Entry";        AppliedEntriesNumbersFilter: Text;    begin        AppliedPaymentEntry.SetRange("Statement Type", "Statement Type");        AppliedPaymentEntry.SetRange("Bank Account No.", "Bank Account No.");        AppliedPaymentEntry.SetRange("Statement No.", "Statement No.");        AppliedPaymentEntry.SetRange("Statement Line No.", "Statement Line No.");        if not AppliedPaymentEntry.FindSet() then            exit;        AppliedEntriesNumbersFilter := Format(AppliedPaymentEntry."Applies-to Entry No.");        if (AppliedPaymentEntry.Next() <> 0) then            repeat                AppliedEntriesNumbersFilter += StrSubstNo(AppliedEntriesFilterLbl, AppliedPaymentEntry."Applies-to Entry No.");            until AppliedPaymentEntry.Next() = 0;        case "Account Type" of            "Account Type"::"G/L Account":                begin                    GLEntry.SetFilter("Entry No.", AppliedEntriesNumbersFilter);                    PAGE.Run(0, GLEntry);                end;            "Account Type"::Customer:                begin                    CustLedgEntry.SetFilter("Entry No.", AppliedEntriesNumbersFilter);                    PAGE.Run(0, CustLedgEntry);                end;            "Account Type"::Vendor:                begin                    VendLedgEntry.SetFilter("Entry No.", AppliedEntriesNumbersFilter);                    PAGE.Run(0, VendLedgEntry);                end;            "Account Type"::"Bank Account":                begin                    AppliedBankAccLedgEntry.SetFilter("Entry No.", AppliedEntriesNumbersFilter);                    PAGE.Run(0, AppliedBankAccLedgEntry);                end;        end;    end;    procedure TransferRemainingAmountToAccount()    var        AppliedPaymentEntry: Record "Applied Payment Entry";    begin        TestField("Account No.");        SetAppliedPaymentEntryFromRec(AppliedPaymentEntry);        AppliedPaymentEntry.Validate("Applied Amount", Difference);        AppliedPaymentEntry.Validate("Match Confidence", AppliedPaymentEntry."Match Confidence"::Manual);        AppliedPaymentEntry.Insert(true);    end;    procedure GetStatusText(): Text    begin        if ("Applied Entries" = 0) and ("Match Confidence" = "Match Confidence"::None) then            exit(NotAppliedTxt);        case "Match Confidence" of            "Match Confidence"::Manual:                exit(AppliedManuallyStatusTxt);            "Match Confidence"::Accepted:                exit(ReviewedStatusTxt);            "Match Confidence"::"High - Text-to-Account Mapping":                exit(MatchedFromTextMappingRulesTxt);            "Match Confidence"::None:                if ("Applied Entries" > 0) then                    exit(MatchedAutomaticallyTxt);            "Match Confidence"::Low, "Match Confidence"::Medium, "Match Confidence"::High:                exit(MatchedAutomaticallyTxt);        end;        Session.LogMessage('0000BN5', StrSubstNo('Unexpected - could not find the status text - Match Confidence %1, Match Quality %2, Applied Entries %3', "Match Confidence", "Match Quality", "Applied Entries"), Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', '');        exit('');    end;    procedure GetAmountRangeForTolerance(var MinAmount: Decimal; var MaxAmount: Decimal)    var        BankAccount: Record "Bank Account";        TempAmount: Decimal;    begin        BankAccount.Get("Bank Account No.");        case BankAccount."Match Tolerance Type" of            BankAccount."Match Tolerance Type"::Amount:                begin                    MinAmount := "Statement Amount" - BankAccount."Match Tolerance Value";                    MaxAmount := "Statement Amount" + BankAccount."Match Tolerance Value";                    if ("Statement Amount" >= 0) and (MinAmount < 0) then                        MinAmount := 0                    else                        if ("Statement Amount" < 0) and (MaxAmount > 0) then                            MaxAmount := 0;                end;            BankAccount."Match Tolerance Type"::Percentage:                begin                    MinAmount := "Statement Amount" * (1 - BankAccount."Match Tolerance Value" / 100);                    MaxAmount := "Statement Amount" * (1 + BankAccount."Match Tolerance Value" / 100);                    if "Statement Amount" < 0 then begin                        TempAmount := MinAmount;                        MinAmount := MaxAmount;                        MaxAmount := TempAmount;                    end;                end;        end;        MinAmount := Round(MinAmount);        MaxAmount := Round(MaxAmount);    end;    procedure GetAppliedPmtData(var AppliedPmtEntry: Record "Applied Payment Entry"; var RemainingAmountAfterPosting: Decimal; var DifferenceStatementAmtToApplEntryAmount: Decimal; PmtAppliedToTxt: Text)    var        CurrRemAmtAfterPosting: Decimal;    begin        AppliedPmtEntry.Init();        RemainingAmountAfterPosting := 0;        DifferenceStatementAmtToApplEntryAmount := 0;        AppliedPmtEntry.FilterAppliedPmtEntry(Rec);        AppliedPmtEntry.SetFilter("Applies-to Entry No.", '<>0');        if AppliedPmtEntry.FindSet() then begin            DifferenceStatementAmtToApplEntryAmount := "Statement Amount";            repeat                CurrRemAmtAfterPosting :=                  AppliedPmtEntry.GetRemAmt() -                  AppliedPmtEntry.GetAmtAppliedToOtherStmtLines();                RemainingAmountAfterPosting += CurrRemAmtAfterPosting - AppliedPmtEntry."Applied Amount";                DifferenceStatementAmtToApplEntryAmount -= CurrRemAmtAfterPosting - AppliedPmtEntry."Applied Pmt. Discount";                OnGetAppliedPmtDataOnAfterLoopIteration(Rec, AppliedPmtEntry);            until AppliedPmtEntry.Next() = 0;        end;        if "Applied Entries" > 1 then            AppliedPmtEntry.Description := StrSubstNo(PmtAppliedToTxt, "Applied Entries");    end;    [Scope('OnPrem')]    procedure GetAppliedPmtData(var AppliedPmtEntry: Record "Applied Payment Entry"; PmtAppliedToTxt: Text)    begin        AppliedPmtEntry.Init();        AppliedPmtEntry.FilterAppliedPmtEntry(Rec);        AppliedPmtEntry.SetFilter("Applies-to Entry No.", '<>0');        if "Applied Entries" > 1 then            AppliedPmtEntry.Description := StrSubstNo(PmtAppliedToTxt, "Applied Entries");    end;    local procedure UpdateParentLineStatementAmount()    var        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";    begin        if BankAccReconciliationLine.Get("Statement Type", "Bank Account No.", "Statement No.", "Parent Line No.") then begin            BankAccReconciliationLine.Validate("Statement Amount", "Statement Amount" + BankAccReconciliationLine."Statement Amount");            BankAccReconciliationLine.Modify(true)        end    end;    procedure IsTransactionPostedAndReconciled(): Boolean    var        PostedPaymentReconLine: Record "Posted Payment Recon. Line";        BankAccountStatementLine: Record "Bank Account Statement Line";        ReturnValue: Boolean;        IsHandled: Boolean;    begin        OnBeforeIsTransactionPostedAndReconciled(Rec, ReturnValue, IsHandled);        if IsHandled then            exit(ReturnValue);        if "Transaction ID" <> '' then begin            PostedPaymentReconLine.SetRange("Bank Account No.", "Bank Account No.");            PostedPaymentReconLine.SetRange("Transaction ID", "Transaction ID");            PostedPaymentReconLine.SetRange(Reconciled, true);            if not PostedPaymentReconLine.IsEmpty() then                exit(true);            BankAccountStatementLine.SetRange("Bank Account No.", "Bank Account No.");            BankAccountStatementLine.SetRange("Transaction ID", "Transaction ID");            exit(not BankAccountStatementLine.IsEmpty);        end;        exit(false);    end;    local procedure IsTransactionPostedAndNotReconciled(): Boolean    var        PostedPaymentReconLine: Record "Posted Payment Recon. Line";    begin        if "Transaction ID" <> '' then begin            PostedPaymentReconLine.SetRange("Bank Account No.", "Bank Account No.");            PostedPaymentReconLine.SetRange("Transaction ID", "Transaction ID");            PostedPaymentReconLine.SetRange(Reconciled, false);            exit(not PostedPaymentReconLine.IsEmpty());        end;        exit(false);    end;    local procedure IsTransactionAlreadyImported(): Boolean    var        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";    begin        if "Transaction ID" <> '' then begin            BankAccReconciliationLine.SetRange("Statement Type", "Statement Type");            BankAccReconciliationLine.SetRange("Bank Account No.", "Bank Account No.");            BankAccReconciliationLine.SetRange("Transaction ID", "Transaction ID");            exit(not BankAccReconciliationLine.IsEmpty());        end;        exit(false);    end;    local procedure AllowImportDuplicatedTransactions(): Boolean    var        BankAccReconciliation: Record "Bank Acc. Reconciliation";    begin        BankAccReconciliation.SetLoadFields("Allow Duplicated Transactions");        BankAccReconciliation.Get(Rec."Statement Type", Rec."Bank Account No.", Rec."Statement No.");        exit(BankAccReconciliation."Allow Duplicated Transactions");    end;    local procedure AllowImportOfPostedNotReconciledTransactions(): Boolean    var        BankAccReconciliation: Record "Bank Acc. Reconciliation";    begin        BankAccReconciliation.Get(Rec."Statement Type", Rec."Bank Account No.", Rec."Statement No.");        if BankAccReconciliation."Import Posted Transactions" = BankAccReconciliation."Import Posted Transactions"::" " then begin            BankAccReconciliation."Import Posted Transactions" := BankAccReconciliation."Import Posted Transactions"::No;            if GuiAllowed then                if Confirm(ImportPostedTransactionsQst) then                    BankAccReconciliation."Import Posted Transactions" := BankAccReconciliation."Import Posted Transactions"::Yes;            BankAccReconciliation.Modify();        end;        exit(BankAccReconciliation."Import Posted Transactions" = BankAccReconciliation."Import Posted Transactions"::Yes);    end;    procedure CanImport(): Boolean    begin        if IsTransactionPostedAndReconciled() then            exit(false);        if IsTransactionAlreadyImported() then            if not AllowImportDuplicatedTransactions() then                exit(false);        if IsTransactionPostedAndNotReconciled() then            exit(AllowImportOfPostedNotReconciledTransactions());        exit(true);    end;    procedure BankStatementLinesListIsEmpty(StatementNo: Code[20]; StatementType: Option; BankAccountNo: Code[20]): Boolean    var        BankAccReconciliationLine: record "Bank Acc. Reconciliation Line";    begin        BankAccReconciliationLine.SetRange("Bank Account No.", BankAccountNo);        BankAccReconciliationLine.SetRange("Statement No.", StatementNo);        BankAccReconciliationLine.SetRange("Statement Type", StatementType);        exit(BankAccReconciliationLine.IsEmpty);    end;    local procedure GetSalepersonPurchaserCode(): Code[20]    var        Customer: Record Customer;        Vendor: Record Vendor;    begin        case "Account Type" of            "Account Type"::Customer:                if Customer.Get("Account No.") then                    exit(Customer."Salesperson Code");            "Account Type"::Vendor:                if Vendor.Get("Account No.") then                    exit(Vendor."Purchaser Code");        end;    end;    internal procedure GetAppliesToIDForBankStatement(): Code[50]    begin        exit(CopyStr(Rec."Bank Account No." + '-' + Format(Rec."Statement No."), 1, 50));    end;    procedure GetAppliesToID(): Code[50]    var        CustLedgerEntry: Record "Cust. Ledger Entry";    begin        exit(            CopyStr(                GetAppliesToIDForBankStatement() + '-' + Format(Rec."Statement Line No."),                1,                MaxStrLen(CustLedgerEntry."Applies-to ID")));    end;    procedure GetDescription(): Text[100]    var        AppliedPaymentEntry: Record "Applied Payment Entry";    begin        if Description <> '' then            exit(Description);        AppliedPaymentEntry.FilterAppliedPmtEntry(Rec);        AppliedPaymentEntry.SetFilter("Applies-to Entry No.", '<>%1', 0);        if AppliedPaymentEntry.FindSet() then            if AppliedPaymentEntry.Next() = 0 then                exit(AppliedPaymentEntry.Description);        exit('');    end;    procedure GetMatchedAutomaticallyFilter(): Text    begin        exit(StrSubstNo(MatchedAutomaticallyFilterLbl, "Match Confidence"::None, "Match Confidence"::Low, "Match Confidence"::Medium, "Match Confidence"::High));    end;    procedure CreateDimFromDefaultDim()    var        DefaultDimSource: List of [Dictionary of [Integer, Code[20]]];    begin        InitDefaultDimensionSources(DefaultDimSource);        CreateDim(DefaultDimSource);    end;    local procedure InitDefaultDimensionSources(var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]])    begin        DimMgt.AddDimSource(DefaultDimSource, DimMgt.TypeToTableID1(Rec."Account Type".AsInteger()), Rec."Account No.");        DimMgt.AddDimSource(DefaultDimSource, Database::"Salesperson/Purchaser", GetSalepersonPurchaserCode());        OnAfterInitDefaultDimensionSources(Rec, DefaultDimSource);    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitDefaultDimensionSources(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSetUpNewLine(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; xBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterShowDimensions(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateDim(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; DefaultDimSource: List of [Dictionary of [Integer, Code[20]]])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterFilterBankRecLines(var Rec: Record "Bank Acc. Reconciliation Line"; BankAccRecon: Record "Bank Acc. Reconciliation")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetAccountName(AccountType: Option; AccountNo: Code[20]; var Name: Text)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetAppliedEntryAccountNo(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AppliedToEntryNo: Integer; var AccountNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterOpenAccountPage(AccountType: Option; AccountNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterRemoveAppliedPaymentEntries(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterDrillDownOnNoOfLedgerEntriesBasedOnAmount(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AmountFilter: Text)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterValidateShortcutDimCode(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var xBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; FieldNumber: Integer; var ShortcutDimCode: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeOnModify(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeValidateShortcutDimCode(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var xBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; FieldNumber: Integer; var ShortcutDimCode: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDisplayApplicationOnAfterBankAccLedgEntrySetFilters(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var BankAccLedgEntry: Record "Bank Account Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeIsTransactionPostedAndReconciled(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var ReturnValue: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDisplayApplicationOnAfterSetBankAccReconcLine(var PaymentApplication: Page "Payment Application");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnRemoveApplicationOnAfterBankAccLedgEntrySetFilters(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var BankAccLedgEntry: Record "Bank Account Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetStyle(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var Result: text; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetCustomerLedgerEntriesInAmountRange(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var CustLedgerEntry: Record "Cust. Ledger Entry"; AccountNo: Code[20]; AmountFilter: Text; MinAmount: Decimal; MaxAmount: Decimal; var Result: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetVendorLedgerEntriesInAmountRange(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var VendorLedgerEntry: Record "Vendor Ledger Entry"; AccountNo: Code[20]; AmountFilter: Text; MinAmount: Decimal; MaxAmount: Decimal; var Result: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeShowDimensions(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetAppliedPmtDataOnAfterLoopIteration(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AppliedPmtEntry: Record "Applied Payment Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterTransferFromPostedPaymentReconLine(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; PostedPaymentReconLine: Record "Posted Payment Recon. Line")    begin    end;}