Codeunit 1252 Match Bank Rec. Lines

Base Application, Microsoft.Bank.Reconciliation

src/Layers/W1/BaseApp/Bank/Reconciliation/MatchBankRecLines.Codeunit.al1,147 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.Finance.GeneralLedger.Journal;using System.Telemetry;using System.Utilities;/// <summary>/// Provides automatic and manual matching capabilities for bank reconciliation statement lines./// This codeunit implements sophisticated algorithms to match imported bank statement lines with/// existing bank account ledger entries for traditional bank reconciliation workflows. Supports/// various matching criteria including amounts, dates, document numbers, and text descriptions,/// with configurable tolerance settings and relationship mapping (one-to-one, one-to-many, many-to-one)./// </summary>/// <remarks>/// Key features include automatic matching with scoring algorithms, manual matching override capabilities,/// text similarity matching for complex scenarios, date tolerance handling, amount-based matching with/// precision controls, and comprehensive reporting of match quality and confidence levels./// Integrates with bank account ledger entries, check ledger entries, and provides detailed telemetry/// for performance monitoring and optimization. Used primarily for bank reconciliation rather than/// payment application workflows, focusing on clearing outstanding transactions and identifying discrepancies./// </remarks>codeunit 1252 "Match Bank Rec. Lines"{    trigger OnRun()    begin    end;    var#pragma warning disable AA0470        MatchSummaryMsg: Label '%1 reconciliation lines out of %2 are matched.\\';#pragma warning restore AA0470        MatchDetailsTxt: Label 'This statement line matched the corresponding bank account ledger entry on the following fields: %1.', Comment = '%1 - a comma-separated list of field captions.';        MatchedManuallyTxt: Label 'This statement line was matched manually.';#pragma warning disable AA0470        MissingMatchMsg: Label 'Text shorter than %1 characters cannot be matched.';#pragma warning restore AA0470        ProgressBarMsgTemplateTok: Label '#1##############################', Locked = true;        ProgressBarUpdateTxt: Label 'Processed %1 statement lines.', Comment = '%1 - an integer';        ProgressBarMsg: Label 'Please wait while the operation is being completed.';        ManyToManyNotSupportedErr: Label 'Many-to-Many matchings are not supported';        OverwriteExistingMatchesTxt: Label 'There are lines in this statement that are already matched with ledger entries.\\ Do you want to overwrite the existing matches?';        NoMatchMsg: Label 'The selected lines have no matches to remove';        BankAccountRecTotalAndMatchedLinesLbl: Label 'Total Bank Statement Lines: %1, of those applied: %2', Locked = true;        AutomatchEventNameTelemetryTxt: Label 'Automatch', Locked = true;        BankAccountRecCategoryLbl: Label 'AL Bank Account Rec', Locked = true;        OptimizationDisabledLbl: Label 'Bank Rec. optimization disabled', Locked = true;        PotentiallyBetterMatchLbl: Label 'Bank Rec. better-candidate-found loop', Locked = true;        BankTransactionRequiresTextComparisonsLbl: Label 'Bank Ledger Entry requires text nearness with Bank Rec. Line', Locked = true;        BankRecLineHasNoDateLbl: Label 'Bank Rec. Line has no transaction date specified', Locked = true;        ToleranceDaysLbl: Label 'Tolerance window for matching', Locked = true;        EndOfClassicBankRecMatchLbl: Label 'End of classic Bank Rec. Automatch', Locked = true;        Relation: Option "One-to-One","One-to-Many","Many-to-One";        TextMatchGreater: Option First,Second,Tie;        MatchLengthTreshold: Integer;        NormalizingFactor: Integer;    /// <summary>    /// Creates manual matches between selected bank reconciliation lines and bank account ledger entries.    /// Enables users to override automatic matching decisions by explicitly linking statement lines    /// with specific ledger entries, supporting complex reconciliation scenarios requiring human judgment.    /// </summary>    /// <param name="SelectedBankAccReconciliationLine">Bank reconciliation lines selected for manual matching.</param>    /// <param name="SelectedBankAccountLedgerEntry">Bank account ledger entries to match with selected lines.</param>    procedure MatchManually(var SelectedBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var SelectedBankAccountLedgerEntry: Record "Bank Account Ledger Entry")    var        SelectedBankAccLECount: Integer;        SelectedBankAccRecLinesCount: Integer;    begin        SelectedBankAccLECount := SelectedBankAccountLedgerEntry.Count();        SelectedBankAccRecLinesCount := SelectedBankAccReconciliationLine.Count();        if SelectedBankAccLECount > 1 then            if SelectedBankAccRecLinesCount > 1 then                Error(ManyToManyNotSupportedErr);        if SelectedBankAccLECount >= SelectedBankAccRecLinesCount then            PerformOneToOneOrManyMatch(SelectedBankAccReconciliationLine, SelectedBankAccountLedgerEntry, Relation::"One-to-Many")        else            PerformManyToOneMatch(SelectedBankAccReconciliationLine, SelectedBankAccountLedgerEntry);    end;    local procedure PerformManyToOneMatch(var SelectedBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var SelectedBankAccountLedgerEntry: Record "Bank Account Ledger Entry")    var        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        PaymentMatchingDetails: Record "Payment Matching Details";        BankAccEntrySetReconNo: Codeunit "Bank Acc. Entry Set Recon.-No.";        LineCount: Integer;    begin        if SelectedBankAccountLedgerEntry.FindFirst() then begin            BankAccountLedgerEntry.Get(SelectedBankAccountLedgerEntry."Entry No.");            BankAccEntrySetReconNo.RemoveApplication(BankAccountLedgerEntry);            LineCount := SelectedBankAccReconciliationLine.Count();            BankAccEntrySetReconNo.SetLineCount(LineCount);            RemoveMatchesFromRecLines(SelectedBankAccReconciliationLine);            if SelectedBankAccReconciliationLine.FindSet() then                repeat                    BankAccReconciliationLine.GetBySystemId(SelectedBankAccReconciliationLine.SystemId);                    OnPerformManyToOneMatchOnBeforeApplyEntries(BankAccReconciliationLine, BankAccountLedgerEntry);                    BankAccEntrySetReconNo.ApplyEntries(BankAccReconciliationLine, BankAccountLedgerEntry, Relation::"Many-to-One");                    OnPerformManyToOneMatchOnAfterApplyEntries(BankAccReconciliationLine, BankAccountLedgerEntry);                    PaymentMatchingDetails.CreatePaymentMatchingDetail(BankAccReconciliationLine, MatchedManuallyTxt);                until SelectedBankAccReconciliationLine.Next() = 0;        end;    end;    local procedure PerformOneToOneOrManyMatch(var SelectedBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var SelectedBankAccountLedgerEntry: Record "Bank Account Ledger Entry"; Relation: Option "One-to-One","One-to-Many","Many-to-One")    var        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        PaymentMatchingDetails: Record "Payment Matching Details";        BankAccEntrySetReconNo: Codeunit "Bank Acc. Entry Set Recon.-No.";    begin        if SelectedBankAccReconciliationLine.FindFirst() then begin            BankAccReconciliationLine.Get(              SelectedBankAccReconciliationLine."Statement Type",              SelectedBankAccReconciliationLine."Bank Account No.",              SelectedBankAccReconciliationLine."Statement No.",              SelectedBankAccReconciliationLine."Statement Line No.");            if BankReconciliationLineInManyToOne(SelectedBankAccReconciliationLine) then                RemoveMatchesFromRecLines(SelectedBankAccReconciliationLine);            if SelectedBankAccountLedgerEntry.FindSet() then                repeat                    BankAccountLedgerEntry.Get(SelectedBankAccountLedgerEntry."Entry No.");                    BankAccEntrySetReconNo.RemoveApplication(BankAccountLedgerEntry);                    OnPerformOneToOneOrManyMatchOnBeforeApplyEntries(BankAccReconciliationLine, BankAccountLedgerEntry);                    BankAccEntrySetReconNo.ApplyEntries(BankAccReconciliationLine, BankAccountLedgerEntry, Relation);                    OnPerformOneToOneOrManyMatchOnAfterApplyEntries(BankAccReconciliationLine, BankAccountLedgerEntry);                    PaymentMatchingDetails.CreatePaymentMatchingDetail(BankAccReconciliationLine, MatchedManuallyTxt);                until SelectedBankAccountLedgerEntry.Next() = 0;        end;    end;    /// <summary>    /// Determines whether a bank reconciliation line is part of a many-to-one matching relationship.    /// Checks if the line has multiple bank reconciliation lines matched to a single bank account    /// ledger entry, which requires special handling during removal and processing operations.    /// </summary>    /// <param name="BankAccReconciliationLine">Bank reconciliation line to check for many-to-one relationship.</param>    /// <returns>True if the line is part of a many-to-one match; false otherwise.</returns>    internal procedure BankReconciliationLineInManyToOne(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"): Boolean    var        BankAccRecMatchBuffer: Record "Bank Acc. Rec. Match Buffer";    begin        BankAccReconciliationLine.FilterManyToOneMatches(BankAccRecMatchBuffer);        exit(not BankAccRecMatchBuffer.IsEmpty());    end;    /// <summary>    /// Removes all matches from selected bank reconciliation lines, clearing their applied entries.    /// Unlinks bank account ledger entries and check ledger entries from the reconciliation lines,    /// resetting them to unmatched status for potential re-matching with different entries.    /// </summary>    /// <param name="SelectedBankAccReconciliationLine">Bank reconciliation lines to clear matches from.</param>    procedure RemoveMatchesFromRecLines(var SelectedBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line")    var        MatchesRemoved: Boolean;    begin        RemoveMatchesFromRecLines(SelectedBankAccReconciliationLine, MatchesRemoved);    end;    /// <summary>    /// Removes all matches from selected bank reconciliation lines with detailed tracking of removal status.    /// Unlinks bank account ledger entries and check ledger entries from the reconciliation lines,    /// resetting them to unmatched status while providing feedback on whether any matches were actually removed.    /// </summary>    /// <param name="SelectedBankAccReconciliationLine">Bank reconciliation lines to clear matches from.</param>    /// <param name="MatchesRemoved">Returns true if any matches were removed; false if no matches existed.</param>    procedure RemoveMatchesFromRecLines(var SelectedBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var MatchesRemoved: Boolean)    var        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        CheckLedgerEntry: Record "Check Ledger Entry";        BankAccRecMatchBuffer: Record "Bank Acc. Rec. Match Buffer";        BankAccEntrySetReconNo: Codeunit "Bank Acc. Entry Set Recon.-No.";        CheckEntrySetReconNo: Codeunit "Check Entry Set Recon.-No.";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRemoveMatchesFromRecLines(IsHandled);        if IsHandled then            exit;        if SelectedBankAccReconciliationLine.FindSet() then            repeat                BankAccReconciliationLine.Get(                  SelectedBankAccReconciliationLine."Statement Type",                  SelectedBankAccReconciliationLine."Bank Account No.",                  SelectedBankAccReconciliationLine."Statement No.",                  SelectedBankAccReconciliationLine."Statement Line No.");                BankAccountLedgerEntry.SetCurrentKey("Bank Account No.", Open);                BankAccountLedgerEntry.SetRange("Bank Account No.", BankAccReconciliationLine."Bank Account No.");                BankAccountLedgerEntry.SetRange("Statement No.", BankAccReconciliationLine."Statement No.");                BankAccountLedgerEntry.SetRange("Statement Line No.", BankAccReconciliationLine."Statement Line No.");                BankAccountLedgerEntry.SetRange(Open, true);                BankAccountLedgerEntry.SetRange("Statement Status", BankAccountLedgerEntry."Statement Status"::"Bank Acc. Entry Applied");                if BankAccountLedgerEntry.FindSet() then begin                    MatchesRemoved := true;                    repeat                        BankAccEntrySetReconNo.RemoveApplication(BankAccountLedgerEntry);                    until BankAccountLedgerEntry.Next() = 0;                end;                BankAccountLedgerEntry.Reset();                BankAccReconciliationLine.FilterManyToOneMatches(BankAccRecMatchBuffer);                if BankAccRecMatchBuffer.FindSet() then begin                    MatchesRemoved := true;                    repeat                        BankAccountLedgerEntry.Get(BankAccRecMatchBuffer."Ledger Entry No.");                        BankAccEntrySetReconNo.RemoveApplication(BankAccountLedgerEntry);                    until BankAccRecMatchBuffer.Next() = 0;                end;                CheckLedgerEntry.SetCurrentKey("Bank Account No.", Open);                CheckLedgerEntry.SetRange("Bank Account No.", BankAccReconciliationLine."Bank Account No.");                CheckLedgerEntry.SetRange("Statement No.", BankAccReconciliationLine."Statement No.");                CheckLedgerEntry.SetRange("Statement Line No.", BankAccReconciliationLine."Statement Line No.");                CheckLedgerEntry.SetRange("Statement Status", CheckLedgerEntry."Statement Status"::"Check Entry Applied");                CheckLedgerEntry.SetRange(Open, true);                if CheckLedgerEntry.FindSet() then begin                    MatchesRemoved := true;                    repeat                        CheckEntrySetReconNo.RemoveApplication(CheckLedgerEntry);                    until CheckLedgerEntry.Next() = 0;                end;            until SelectedBankAccReconciliationLine.Next() = 0;    end;    /// <summary>    /// Removes specific matches between selected bank reconciliation lines and bank account ledger entries.    /// Provides granular control over match removal by targeting specific entry combinations rather than    /// clearing all matches from a line. Handles both bank account ledger entries and check ledger entries    /// with appropriate status updates and application removal.    /// </summary>    /// <param name="SelectedBankAccReconciliationLine">Bank reconciliation lines containing matches to remove.</param>    /// <param name="SelectedBankAccountLedgerEntry">Specific bank account ledger entries to unlink from the lines.</param>    procedure RemoveMatch(var SelectedBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var SelectedBankAccountLedgerEntry: Record "Bank Account Ledger Entry")    var        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        CheckLedgEntry: Record "Check Ledger Entry";        BankAccEntrySetReconNo: Codeunit "Bank Acc. Entry Set Recon.-No.";        CheckEntrySetReconNo: Codeunit "Check Entry Set Recon.-No.";        MatchesRemoved: Boolean;    begin        MatchesRemoved := false;        RemoveMatchesFromRecLines(SelectedBankAccReconciliationLine, MatchesRemoved);        if SelectedBankAccountLedgerEntry.FindSet() then            repeat                case SelectedBankAccountLedgerEntry."Statement Status" of                    SelectedBankAccountLedgerEntry."Statement Status"::"Bank Acc. Entry Applied":                        begin                            BankAccountLedgerEntry.Get(SelectedBankAccountLedgerEntry."Entry No.");                            BankAccEntrySetReconNo.RemoveApplication(BankAccountLedgerEntry);                            OnRemoveMatchOnAfterRemoveApplication(BankAccountLedgerEntry);                            MatchesRemoved := true;                        end;                    SelectedBankAccountLedgerEntry."Statement Status"::"Check Entry Applied":                        begin                            CheckLedgEntry.Reset();                            CheckLedgEntry.SetCurrentKey("Bank Account Ledger Entry No.");                            CheckLedgEntry.SetRange("Bank Account Ledger Entry No.", SelectedBankAccountLedgerEntry."Entry No.");                            CheckLedgEntry.SetRange(Open, true);                            if CheckLedgEntry.FindSet() then                                repeat                                    CheckEntrySetReconNo.RemoveApplication(CheckLedgEntry);                                until CheckLedgEntry.Next() = 0;                            MatchesRemoved := true;                        end;                end;            until SelectedBankAccountLedgerEntry.Next() = 0;        if not MatchesRemoved then            Message(NoMatchMsg);    end;    /// <summary>    /// Executes automatic matching algorithm for bank account reconciliation with date tolerance.    /// Analyzes bank statement lines and bank account ledger entries to identify potential matches    /// based on amounts, dates (within tolerance), document numbers, and text descriptions.    /// Updates matched entries by applying them and setting statement references for reconciliation tracking.    /// </summary>    /// <param name="BankAccReconciliation">Bank account reconciliation to process for automatic matching.</param>    /// <param name="DaysTolerance">Number of days tolerance for date matching between statement and ledger entries.</param>    procedure BankAccReconciliationAutoMatch(BankAccReconciliation: Record "Bank Acc. Reconciliation"; DaysTolerance: Integer)    begin        BankAccReconciliationAutoMatch(BankAccReconciliation, DaysTolerance, false, true);    end;    /// <summary>    /// Executes comprehensive automatic matching algorithm for bank account reconciliation with advanced options.    /// Provides full control over the matching process including event handling, optimization settings,    /// and result presentation. Analyzes bank statement lines and bank account ledger entries using    /// sophisticated scoring algorithms based on amount, date, document number, and text similarity matching.    /// </summary>    /// <param name="BankAccReconciliation">Bank account reconciliation to process for automatic matching.</param>    /// <param name="DaysTolerance">Number of days tolerance for date matching between statement and ledger entries.</param>    /// <param name="RaiseFindBestMatchesEvent">Whether to raise integration events for custom matching logic.</param>    /// <param name="ShouldShowMatchSummary">Whether to display summary notification with matching results.</param>    procedure BankAccReconciliationAutoMatch(var BankAccReconciliation: Record "Bank Acc. Reconciliation"; DaysTolerance: Integer; RaiseFindBestMatchesEvent: Boolean; ShouldShowMatchSummary: Boolean)    var        BankAccount: Record "Bank Account";        TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary;        TempBankAccLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary;        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";        UndoMatchOnBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        ConfirmManagement: Codeunit "Confirm Management";        FeatureTelemetry: Codeunit "Feature Telemetry";        ProgressDialog: Dialog;        Overwrite: Boolean;        DisableOptimization: Boolean;        RemovedPreviouslyAssigned: Boolean;        Handled: Boolean;        BankAccRecLineCounter: Integer;        OriginallyMatchedBankAccRecLineNos: List of [Integer];    begin        BankAccount.Get(BankAccReconciliation."Bank Account No.");        DisableOptimization := BankAccount."Disable Bank Rec. Optimization";        if DisableOptimization then            Session.LogMessage('0000NUK', OptimizationDisabledLbl, Verbosity::Verbose, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl);        Session.LogMessage('0000NUL', ToleranceDaysLbl, Verbosity::Verbose, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl, 'Tolerance', Format(DaysTolerance));        FeatureTelemetry.LogUptake('0000JLB', BankAccReconciliation.GetBankReconciliationTelemetryFeatureName(), Enum::"Feature Uptake Status"::Used);        Overwrite := true;        BankAccRecLineCounter := 0;        BankAccReconciliationLine.FilterBankRecLines(BankAccReconciliation);        BankAccReconciliationLine.SetFilter("Applied Entries", '<>%1', 0);        if not BankAccReconciliationLine.IsEmpty() then begin            Overwrite := ConfirmManagement.GetResponseOrDefault(OverwriteExistingMatchesTxt, false);            if Overwrite then begin                BankAccReconciliationLine.Reset();                BankAccReconciliationLine.SetFilter("Bank Account No.", BankAccReconciliation."Bank Account No.");                BankAccReconciliationLine.SetFilter("Statement No.", BankAccReconciliation."Statement No.");                RemoveMatchesFromRecLines(BankAccReconciliationLine);            end else                if BankAccReconciliationLine.FindSet() then                    repeat                        OriginallyMatchedBankAccRecLineNos.Add(BankAccReconciliationLine."Statement Line No.");                    until BankAccReconciliationLine.Next() = 0;        end;        if GuiAllowed() then begin            ProgressDialog.Open(ProgressBarMsgTemplateTok);            ProgressDialog.Update(1, ProgressBarMsg);        end;        // Lines to match        BankAccReconciliationLine.Reset();        BankAccReconciliationLine.FilterBankRecLinesByDate(BankAccReconciliation, Overwrite);        // Candidate Bank Account Ledger Entries        BankAccountLedgerEntry.SetBankReconciliationCandidatesFilter(BankAccReconciliation);        InitializeBLEMatchingTempTable(TempBankAccLedgerEntryMatchingBuffer, BankAccountLedgerEntry);        // Both candidate Bank Account Ledger Entries and lines to match are sorted by dates as this can be used to        // easily get rid of many matching candidates outside the range.        // Bank Rec. Lines may have an empty Transaction date, they are sorted first and these will        // be attempted to match with every other candidate.        repeat            TempBankStatementMatchingBuffer.DeleteAll();            RemovedPreviouslyAssigned := false;            if not TempBankAccLedgerEntryMatchingBuffer.IsEmpty() then                if BankAccReconciliationLine.FindSet() then                    repeat                        if GuiAllowed() then                            if BankAccRecLineCounter > 999 then                                if BankAccRecLineCounter mod 1000 = 0 then                                    ProgressDialog.Update(1, StrSubstNo(ProgressBarUpdateTxt, BankAccRecLineCounter));                        // If there are no candidate Bank Account Ledger Entries left, we can stop as there will be no other match                        if TempBankAccLedgerEntryMatchingBuffer.IsEmpty() then                            break;                        AttemptToMatch(BankAccReconciliationLine, TempBankAccLedgerEntryMatchingBuffer, DaysTolerance, TempBankStatementMatchingBuffer, RemovedPreviouslyAssigned, DisableOptimization);                        BankAccRecLineCounter += 1                    until (BankAccReconciliationLine.Next() = 0);            SaveOneToOneMatching(TempBankStatementMatchingBuffer, BankAccReconciliation."Bank Account No.", BankAccReconciliation."Statement No.");            if RemovedPreviouslyAssigned then begin                Session.LogMessage('0000NUM', PotentiallyBetterMatchLbl, Verbosity::Verbose, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl);                BankAccountLedgerEntry.SetBankReconciliationCandidatesFilter(BankAccReconciliation);                InitializeBLEMatchingTempTable(TempBankAccLedgerEntryMatchingBuffer, BankAccountLedgerEntry);                BankAccReconciliationLine.Reset();                BankAccReconciliationLine.FilterBankRecLinesByDate(BankAccReconciliation, false);            end;        until not RemovedPreviouslyAssigned;        Session.LogMessage('0000NUN', EndOfClassicBankRecMatchLbl, Verbosity::Verbose, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl);        if GuiAllowed() then            ProgressDialog.Close();        if RaiseFindBestMatchesEvent then begin            BankAccountLedgerEntry.SetBankReconciliationCandidatesFilter(BankAccReconciliation);            InitializeBLEMatchingTempTable(TempBankAccLedgerEntryMatchingBuffer, BankAccountLedgerEntry);            BankAccReconciliationLine.Reset();            BankAccReconciliationLine.FilterBankRecLinesByDate(BankAccReconciliation, false);            if BankAccReconciliationLine.FindSet() then begin                OnFindBestMatches(BankAccReconciliationLine, TempBankAccLedgerEntryMatchingBuffer, DaysTolerance, TempBankStatementMatchingBuffer, RemovedPreviouslyAssigned, Handled);                if Handled then begin                    BankAccountLedgerEntry.SetBankReconciliationCandidatesFilter(BankAccReconciliation);                    InitializeBLEMatchingTempTable(TempBankAccLedgerEntryMatchingBuffer, BankAccountLedgerEntry);                    BankAccReconciliationLine.Reset();                    BankAccReconciliationLine.FilterBankRecLinesByDate(BankAccReconciliation, false);                end else begin                    UndoMatchOnBankAccReconciliationLine.FilterBankRecLines(BankAccReconciliation);                    UndoMatchOnBankAccReconciliationLine.SetFilter("Applied Entries", '<>%1', 0);                    if UndoMatchOnBankAccReconciliationLine.FindSet() then                        repeat                            if not OriginallyMatchedBankAccRecLineNos.Contains(UndoMatchOnBankAccReconciliationLine."Statement Line No.") then                                UndoMatchOnBankAccReconciliationLine.Mark(true);                        until UndoMatchOnBankAccReconciliationLine.Next() = 0;                    UndoMatchOnBankAccReconciliationLine.MarkedOnly(true);                    RemoveMatchesFromRecLines(UndoMatchOnBankAccReconciliationLine);                end;            end;        end;        if ShouldShowMatchSummary then            ShowMatchSummary(BankAccReconciliation);        FeatureTelemetry.LogUsage('0000JLC', BankAccReconciliation.GetBankReconciliationTelemetryFeatureName(), AutomatchEventNameTelemetryTxt);    end;    /// <summary>    /// Given a BankAccReconciliationLine it attempts to find a match from the non-empty temporary table candidates in    /// TempBankAccLedgerEntryMatchingBuffer. It considers DaysTolerance as configuration parameter.    ///     /// It uses the assumption that entries in TempBankAccLedgerEntryMatchingBuffer are sorted ascendingly by Posting Date and that    /// subsequent calls during an automatch have their Transaction Date increasing as well.    ///     /// If a match is found, the match details are inserted in the TempBankStatementMatchingBuffer. Multiple matches can be inserted.    ///     /// </summary>    /// <param name="BankAccReconciliationLine">Record loaded with the line to find a match for, subsequent calls make the assumption that it was called on a set ordered by Transaction Date</param>    /// <param name="TempBankAccLedgerEntryMatchingBuffer">Candidate Bank Account Ledger Entries to consider for the match sorted by Posting Date</param>    /// <param name="DaysTolerance">Days of tolerance allowed</param>    /// <param name="TempBankStatementMatchingBuffer">Temporary table where the match is inserted if found</param>    local procedure AttemptToMatch(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempBankAccLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; DaysTolerance: Integer; var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var RemovedPreviouslyAssigned: Boolean; DisableOptimization: Boolean)    var        TempBestBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary;        TempMatchingDetailsBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary;        BankTransactionTooEarly: Boolean;        BankTransactionTooLate: Boolean;        ShouldContinueTryingToMatch: Boolean;    begin        TempBestBankStatementMatchingBuffer.Reset();        if not TempBankAccLedgerEntryMatchingBuffer.FindSet() then            exit;        repeat            // Date assumptions are only considered when Bank Rec. Line has Transaction Date <> 0            if BankAccReconciliationLine."Transaction Date" <> 0D then begin                BankTransactionTooEarly := (BankAccReconciliationLine."Transaction Date" - TempBankAccLedgerEntryMatchingBuffer."Posting Date") > DaysTolerance;                BankTransactionTooLate := (TempBankAccLedgerEntryMatchingBuffer."Posting Date" - BankAccReconciliationLine."Transaction Date") > DaysTolerance;            end            else                Session.LogMessage('0000NUO', BankRecLineHasNoDateLbl, Verbosity::Verbose, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl);            // Subsequent calls to this method are with Bank Rec Lines sorted ascending by Transaction date, therefore            // if a candidate BLE is too early for this Bank Rec Line, it will be too early for posterior calls as well.            // These are removed from the candidates for optimization.            if BankTransactionTooEarly then                TempBankAccLedgerEntryMatchingBuffer.Delete();            if (not BankTransactionTooEarly) and (not BankTransactionTooLate) then begin                TempMatchingDetailsBankStatementMatchingBuffer.Reset();                Session.LogMessage('0000NUP', BankTransactionRequiresTextComparisonsLbl, Verbosity::Verbose, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl);                if MatchingIsAcceptable(BankAccReconciliationLine, TempBankAccLedgerEntryMatchingBuffer, TempMatchingDetailsBankStatementMatchingBuffer) then begin                    if (not DisableOptimization) and MatchingIsHighConfidence(TempMatchingDetailsBankStatementMatchingBuffer) then                        if AddMatchToCandidatesIfBetter(TempBankStatementMatchingBuffer, TempMatchingDetailsBankStatementMatchingBuffer, RemovedPreviouslyAssigned) then                            exit;                    if MatchIsBetter(TempMatchingDetailsBankStatementMatchingBuffer, TempBestBankStatementMatchingBuffer) then                        if BestMatchingCandidateForBankAccountLedgerEntryIsWorse(TempBankStatementMatchingBuffer, TempMatchingDetailsBankStatementMatchingBuffer) then                            TempBestBankStatementMatchingBuffer.Copy(TempMatchingDetailsBankStatementMatchingBuffer);                end            end;            // If the candidate is too late, then we can stop already as Bank Ledger Entries are sorted by Posting Date (BankTransactionTooLate will always be true after)            ShouldContinueTryingToMatch := (TempBankAccLedgerEntryMatchingBuffer.Next() <> 0) and (not BankTransactionTooLate);        until not ShouldContinueTryingToMatch;        if TempBestBankStatementMatchingBuffer."Entry No." <> 0 then            AddMatchToCandidatesIfBetter(TempBankStatementMatchingBuffer, TempBestBankStatementMatchingBuffer, RemovedPreviouslyAssigned);    end;    local procedure AddMatchToCandidatesIfBetter(var CandidatesBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var ToAddBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var RemovedPreviouslyAssigned: Boolean): Boolean    begin        CandidatesBankStatementMatchingBuffer.SetRange("Entry No.", ToAddBankStatementMatchingBuffer."Entry No.");        if CandidatesBankStatementMatchingBuffer.IsEmpty() then begin            CandidatesBankStatementMatchingBuffer.SetRange("Entry No.");            AddMatchingCandidate(CandidatesBankStatementMatchingBuffer, ToAddBankStatementMatchingBuffer);            exit(true);        end;        if BestMatchingCandidateForBankAccountLedgerEntryIsWorse(CandidatesBankStatementMatchingBuffer, ToAddBankStatementMatchingBuffer) then begin            RemovedPreviouslyAssigned := true;            CandidatesBankStatementMatchingBuffer.SetRange("Entry No.");            RemoveBestMatchingCandidateForBankAccountLedgerEntry(CandidatesBankStatementMatchingBuffer, ToAddBankStatementMatchingBuffer."Entry No.");            AddMatchingCandidate(CandidatesBankStatementMatchingBuffer, ToAddBankStatementMatchingBuffer);            exit(true);        end;        exit(false)    end;    local procedure RemoveBestMatchingCandidateForBankAccountLedgerEntry(var CandidatesBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; BankAccountLedgerEntryNo: Integer)    begin        CandidatesBankStatementMatchingBuffer.SetRange("Entry No.", BankAccountLedgerEntryNo);        CandidatesBankStatementMatchingBuffer.FindFirst();        CandidatesBankStatementMatchingBuffer.Delete();        CandidatesBankStatementMatchingBuffer.SetRange("Entry No.");    end;    local procedure BestMatchingCandidateForBankAccountLedgerEntryIsWorse(var CandidatesBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var ToAddBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary): Boolean    var        Result: Boolean;    begin        CandidatesBankStatementMatchingBuffer.SetRange("Entry No.", ToAddBankStatementMatchingBuffer."Entry No.");        if CandidatesBankStatementMatchingBuffer.IsEmpty() then begin            CandidatesBankStatementMatchingBuffer.SetRange("Entry No.");            exit(true);        end;        CandidatesBankStatementMatchingBuffer.FindFirst();        Result := MatchIsBetter(ToAddBankStatementMatchingBuffer, CandidatesBankStatementMatchingBuffer);        CandidatesBankStatementMatchingBuffer.SetRange("Entry No.");        exit(Result);    end;    local procedure AddMatchingCandidate(var CandidatesBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var ToAddBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary)    begin        CandidatesBankStatementMatchingBuffer.Copy(ToAddBankStatementMatchingBuffer);        CandidatesBankStatementMatchingBuffer.Insert();    end;    /// <summary>    /// Returns true if TempBankStatementMatchingBuffer is better than TempToCompareBankStatementMatchingBuffer    /// </summary>    /// <param name="TempBankStatementMatchingBuffer"></param>    /// <param name="TempToCompareBankStatementMatchingBuffer"></param>    /// <returns></returns>    local procedure MatchIsBetter(var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var TempToCompareBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary): Boolean    var        AmountDifferenceSmaller: Boolean;        DateDifferenceSmaller: Boolean;        TextMatchingBetter: Boolean;    begin        if TempToCompareBankStatementMatchingBuffer."Entry No." = 0 then            exit(true);        AmountDifferenceSmaller := Abs(TempBankStatementMatchingBuffer."Amount Difference") < Abs(TempToCompareBankStatementMatchingBuffer."Amount Difference");        DateDifferenceSmaller := Abs(TempBankStatementMatchingBuffer."Date Difference") < Abs(TempToCompareBankStatementMatchingBuffer."Date Difference");        TextMatchingBetter := IsTextMatchingBetter(TempBankStatementMatchingBuffer, TempToCompareBankStatementMatchingBuffer);        if AmountDifferenceSmaller then            exit(true);        if Abs(TempBankStatementMatchingBuffer."Amount Difference") > Abs(TempToCompareBankStatementMatchingBuffer."Amount Difference") then            exit(false);        // Amount differences are equal in both matches        if TextMatchingBetter then            exit(true);        if IsTextMatchingBetter(TempToCompareBankStatementMatchingBuffer, TempBankStatementMatchingBuffer) then            exit(false);        // Text scores are equally good in both matches        exit(DateDifferenceSmaller);    end;    /// <summary>    /// Returns true if the text matchings in TempBankStatementMatchingBuffer are better than TempToCompareBankStatementMatchingBuffer    /// </summary>    /// <param name="TempBankStatementMatchingBuffer"></param>    /// <param name="TempToCompareBankStatementMatchingBuffer"></param>    /// <returns></returns>    local procedure IsTextMatchingBetter(var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var TempToCompareBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary): Boolean    var        FirstDocNoScore, SecondDocNoScore, WinnerDocNoScore : Integer;        FirstExtDocNoScore, SecondExtDocNoScore, WinnerExtDocNoScore : Integer;        FirstDescriptionScore, SecondDescriptionScore, WinnerDescriptionScore : Integer;        ComparisonResultDocNo, ComparisonResultExtDocNo, ComparisonResultDescription : Option;        BestMaxWinner: Option;    begin        FirstDocNoScore := GetMax(TempBankStatementMatchingBuffer."Doc. No. Score", TempBankStatementMatchingBuffer."Doc. No. Exact Score");        SecondDocNoScore := GetMax(TempToCompareBankStatementMatchingBuffer."Doc. No. Score", TempToCompareBankStatementMatchingBuffer."Doc. No. Exact Score");        FirstExtDocNoScore := GetMax(TempBankStatementMatchingBuffer."Ext. Doc. No. Score", TempBankStatementMatchingBuffer."Ext. Doc. No. Exact Score");        SecondExtDocNoScore := GetMax(TempToCompareBankStatementMatchingBuffer."Ext. Doc. No. Score", TempToCompareBankStatementMatchingBuffer."Ext. Doc. No. Exact Score");        FirstDescriptionScore := GetMax(TempBankStatementMatchingBuffer."Description Score", TempBankStatementMatchingBuffer."Description Exact Score");        SecondDescriptionScore := GetMax(TempToCompareBankStatementMatchingBuffer."Description Score", TempToCompareBankStatementMatchingBuffer."Description Exact Score");        TextScoreGreaterThan(FirstDocNoScore, SecondDocNoScore, ComparisonResultDocNo, WinnerDocNoScore);        TextScoreGreaterThan(FirstExtDocNoScore, SecondExtDocNoScore, ComparisonResultExtDocNo, WinnerExtDocNoScore);        TextScoreGreaterThan(FirstDescriptionScore, SecondDescriptionScore, ComparisonResultDescription, WinnerDescriptionScore);        GetMaxScoreOfWinner(ComparisonResultDocNo, WinnerDocNoScore, ComparisonResultExtDocNo, WinnerExtDocNoScore, ComparisonResultDescription, WinnerDescriptionScore, BestMaxWinner);        if BestMaxWinner = TextMatchGreater::Tie then            exit(false);        if BestMaxWinner = TextMatchGreater::First then            exit(true);        if BestMaxWinner = TextMatchGreater::Second then            exit(false);    end;    /// <summary>    /// There are 3 scores associated to how well does Bank Rec. Line **text fields** match a specific Bank Account Ledger Entry:    /// - Doc. No Score    /// - Ext. Doc. No Score    /// - Description Score    /// When we compare two matches, we first compare how well they do on each category. If one match is better in a category, it wins that category.    /// The Option parameter values are used to store the winner of each category. The Integer parameter values contain the winning score for that category.    ///    /// The best match is considered as the one for which a category has the highest winning score. This reflects the fact that there is usually one field used to match exactly, while the other fields do not necessarily matter.    /// The result of the best match is stored in the output parameter BestMaxWinner.    /// </summary>    local procedure GetMaxScoreOfWinner(ComparisonResultDocNo: Option; WinnerDocNoScore: Integer; ComparisonResultExtDocNo: Option; WinnerExtDocNoScore: Integer; ComparisonResultDescription: Option; WinnerDescriptionScore: Integer; var BestMaxWinner: Option)    var        MaxWinningScore: Integer;    begin        BestMaxWinner := TextMatchGreater::Tie;        if ComparisonResultDocNo <> TextMatchGreater::Tie then begin            MaxWinningScore := WinnerDocNoScore;            BestMaxWinner := ComparisonResultDocNo        end;        if BestMaxWinner = TextMatchGreater::Tie then begin            if ComparisonResultExtDocNo <> TextMatchGreater::Tie then begin                MaxWinningScore := WinnerExtDocNoScore;                BestMaxWinner := ComparisonResultExtDocNo;            end;        end else            if ComparisonResultExtDocNo <> TextMatchGreater::Tie then                if MaxWinningScore < WinnerExtDocNoScore then begin                    MaxWinningScore := WinnerExtDocNoScore;                    BestMaxWinner := ComparisonResultExtDocNo;                end;        if BestMaxWinner = TextMatchGreater::Tie then begin            if ComparisonResultDescription <> TextMatchGreater::Tie then begin                MaxWinningScore := WinnerDescriptionScore;                BestMaxWinner := ComparisonResultDescription;            end;        end else            if ComparisonResultDescription <> TextMatchGreater::Tie then                if MaxWinningScore < WinnerDescriptionScore then begin                    MaxWinningScore := WinnerDescriptionScore;                    BestMaxWinner := ComparisonResultDescription;                end;    end;    local procedure TextScoreGreaterThan(TextScore1: Integer; TextScore2: Integer; var Result: Option; var WinnerScoreValue: Integer)    begin        if TextScore1 > TextScore2 then begin            WinnerScoreValue := TextScore1;            Result := TextMatchGreater::First;            exit;        end;        if TextScore2 > TextScore1 then begin            WinnerScoreValue := TextScore2;            Result := TextMatchGreater::Second;            exit;        end;        WinnerScoreValue := TextScore1;        Result := TextMatchGreater::Tie;    end;    local procedure GetMax(N1: Integer; N2: Integer): Integer    begin        if N1 > N2 then            exit(N1);        exit(N2);    end;    local procedure GetMaxTextNearnessScore(TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary): Integer    var        MaxTextScore: Integer;    begin        MaxTextScore := TempBankStatementMatchingBuffer."Doc. No. Score";        if MaxTextScore < TempBankStatementMatchingBuffer."Ext. Doc. No. Score" then            MaxTextScore := TempBankStatementMatchingBuffer."Ext. Doc. No. Score";        if MaxTextScore < TempBankStatementMatchingBuffer."Description Score" then            MaxTextScore := TempBankStatementMatchingBuffer."Description Score";        exit(MaxTextScore);    end;    local procedure GetMaxTextExactScore(TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary): Integer    var        MaxTextScore: Integer;    begin        MaxTextScore := TempBankStatementMatchingBuffer."Doc. No. Exact Score";        if MaxTextScore < TempBankStatementMatchingBuffer."Ext. Doc. No. Exact Score" then            MaxTextScore := TempBankStatementMatchingBuffer."Ext. Doc. No. Exact Score";        if MaxTextScore < TempBankStatementMatchingBuffer."Description Exact Score" then            MaxTextScore := TempBankStatementMatchingBuffer."Description Exact Score";        exit(MaxTextScore);    end;    local procedure MatchingIsHighConfidence(TempMatchingDetailsBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary): Boolean    begin        exit((TempMatchingDetailsBankStatementMatchingBuffer."Date Difference" = 0) and            (TempMatchingDetailsBankStatementMatchingBuffer."Amount Difference" = 0) and            (GetMaxTextNearnessScore(TempMatchingDetailsBankStatementMatchingBuffer) >= 95) and            (GetMaxTextExactScore(TempMatchingDetailsBankStatementMatchingBuffer) >= 95));    end;    local procedure MatchingIsAcceptable(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempBankAccLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var TempMatchingDetailsBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary): Boolean    var        AmountMatched: Boolean;        AmountClose: Boolean;        TransactionDateMatched: Boolean;        DocumentNoMatched: Boolean;        ExternalDocumentNoMatched: Boolean;        DescriptionMatched: Boolean;        ListOfMatchFields: Text;    begin        // We compute and load all the required information about their match        TempMatchingDetailsBankStatementMatchingBuffer.Init();        if BankAccReconciliationLine."Transaction Date" = 0D then            TempMatchingDetailsBankStatementMatchingBuffer."Date Difference" := 0        else            TempMatchingDetailsBankStatementMatchingBuffer."Date Difference" := TempBankAccLedgerEntryMatchingBuffer."Posting Date" - BankAccReconciliationLine."Transaction Date";        TempMatchingDetailsBankStatementMatchingBuffer."Amount Difference" := TempBankAccLedgerEntryMatchingBuffer."Remaining Amount" - BankAccReconciliationLine.Difference;        AmountMatched := (TempMatchingDetailsBankStatementMatchingBuffer."Amount Difference" = 0);        AmountClose := IsAmountClose(TempBankAccLedgerEntryMatchingBuffer."Remaining Amount", BankAccReconciliationLine.Difference);        if not AmountClose then            exit(false);        BankReconciliationLineTextSimilarityScores(TempBankAccLedgerEntryMatchingBuffer."Document No.", BankAccReconciliationLine, TempMatchingDetailsBankStatementMatchingBuffer."Doc. No. Score", TempMatchingDetailsBankStatementMatchingBuffer."Doc. No. Exact Score");        BankReconciliationLineTextSimilarityScores(TempBankAccLedgerEntryMatchingBuffer."External Document No.", BankAccReconciliationLine, TempMatchingDetailsBankStatementMatchingBuffer."Ext. Doc. No. Score", TempMatchingDetailsBankStatementMatchingBuffer."Ext. Doc. No. Exact Score");        BankReconciliationLineTextSimilarityScores(TempBankAccLedgerEntryMatchingBuffer.Description, BankAccReconciliationLine, TempMatchingDetailsBankStatementMatchingBuffer."Description Score", TempMatchingDetailsBankStatementMatchingBuffer."Description Exact Score");        TempMatchingDetailsBankStatementMatchingBuffer."Line No." := BankAccReconciliationLine."Statement Line No.";        TempMatchingDetailsBankStatementMatchingBuffer."Entry No." := TempBankAccLedgerEntryMatchingBuffer."Entry No.";        TempMatchingDetailsBankStatementMatchingBuffer."Account Type" := Enum::"Gen. Journal Account Type"::"G/L Account";        TempMatchingDetailsBankStatementMatchingBuffer."Account No." := '';        if BankAccReconciliationLine."Transaction Date" <> 0D then            TransactionDateMatched := (TempMatchingDetailsBankStatementMatchingBuffer."Date Difference" = 0);        DocumentNoMatched := (TempMatchingDetailsBankStatementMatchingBuffer."Doc. No. Score" >= 80) or (TempMatchingDetailsBankStatementMatchingBuffer."Doc. No. Exact Score" = 100);        ExternalDocumentNoMatched := (TempMatchingDetailsBankStatementMatchingBuffer."Ext. Doc. No. Score" >= 80) or (TempMatchingDetailsBankStatementMatchingBuffer."Ext. Doc. No. Exact Score" = 100);        DescriptionMatched := (TempMatchingDetailsBankStatementMatchingBuffer."Description Score" >= 80) or (TempMatchingDetailsBankStatementMatchingBuffer."Description Exact Score" = 100);        ListOfMatchFields := ListOfMatchedFields(AmountMatched, DocumentNoMatched, ExternalDocumentNoMatched, TransactionDateMatched, false, DescriptionMatched);        TempMatchingDetailsBankStatementMatchingBuffer."Match Details" := StrSubstNo(MatchDetailsTxt, ListOfMatchFields);        if AmountMatched then            exit(true);        exit(DocumentNoMatched or ExternalDocumentNoMatched or DescriptionMatched);    end;    local procedure IsAmountClose(TargetAmount: Decimal; StatementAmount: Decimal): Boolean    var        Ratio: Decimal;    begin        if (TargetAmount = 0) or (StatementAmount = 0) then            exit(false);        if not SameSign(TargetAmount, StatementAmount) then            exit(false);        Ratio := Abs(StatementAmount) / Abs(TargetAmount);        exit((Ratio > 0.6) and (Ratio < 1.1));    end;    local procedure SameSign(Amount1: Decimal; Amount2: Decimal): Boolean    begin        if (Amount1 = 0) or (Amount2 = 0) then            exit(false);        exit((Amount1 div Abs(Amount1)) = (Amount2 div Abs(Amount2)));    end;    /// <summary>    /// Computes both nearness and exact scores between TextToMatch and all BankAccReconciliationLine text fields in a    /// single pass, short-circuiting as soon as both scores reach 100.    /// Fields checked in order: Description, Related-Party Name, Additional Transaction Info, Document No.    /// </summary>    /// <param name="TextToMatch">The text from the Bank Account Ledger Entry to match against</param>    /// <param name="BankAccReconciliationLine">The bank reconciliation line whose fields are compared</param>    /// <param name="NearScore">Output: best nearness score (0-100) across all line fields</param>    /// <param name="ExactScore">Output: best exact score (0-100) across all line fields</param>    local procedure BankReconciliationLineTextSimilarityScores(TextToMatch: Text; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var NearScore: Integer; var ExactScore: Integer)    var        RecordMatchMgt: Codeunit "Record Match Mgt.";        FieldNear: Integer;        FieldExact: Integer;    begin        NearScore := 0;        ExactScore := 0;        if TextToMatch = '' then            exit;        FieldNear := RecordMatchMgt.CalculateStringNearness(BankAccReconciliationLine.Description, TextToMatch, 4, 100);        FieldExact := RecordMatchMgt.CalculateExactStringNearness(BankAccReconciliationLine.Description, TextToMatch, 100);        if FieldNear > NearScore then            NearScore := FieldNear;        if FieldExact > ExactScore then            ExactScore := FieldExact;        if (NearScore = 100) and (ExactScore = 100) then            exit;        FieldNear := RecordMatchMgt.CalculateStringNearness(BankAccReconciliationLine."Related-Party Name", TextToMatch, 4, 100);        FieldExact := RecordMatchMgt.CalculateExactStringNearness(BankAccReconciliationLine."Related-Party Name", TextToMatch, 100);        if FieldNear > NearScore then            NearScore := FieldNear;        if FieldExact > ExactScore then            ExactScore := FieldExact;        if (NearScore = 100) and (ExactScore = 100) then            exit;        FieldNear := RecordMatchMgt.CalculateStringNearness(BankAccReconciliationLine."Additional Transaction Info", TextToMatch, 4, 100);        FieldExact := RecordMatchMgt.CalculateExactStringNearness(BankAccReconciliationLine."Additional Transaction Info", TextToMatch, 100);        if FieldNear > NearScore then            NearScore := FieldNear;        if FieldExact > ExactScore then            ExactScore := FieldExact;        if (NearScore = 100) and (ExactScore = 100) then            exit;        FieldNear := RecordMatchMgt.CalculateStringNearness(BankAccReconciliationLine."Document No.", TextToMatch, 4, 100);        FieldExact := RecordMatchMgt.CalculateExactStringNearness(BankAccReconciliationLine."Document No.", TextToMatch, 100);        if FieldNear > NearScore then            NearScore := FieldNear;        if FieldExact > ExactScore then            ExactScore := FieldExact;    end;    procedure InitializeBLEMatchingTempTable(var TempBankAccLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var BankAccountLedgerEntry: Record "Bank Account Ledger Entry")    begin        TempBankAccLedgerEntryMatchingBuffer.Reset();        TempBankAccLedgerEntryMatchingBuffer.DeleteAll();        if not BankAccountLedgerEntry.FindSet() then            exit;        repeat            TempBankAccLedgerEntryMatchingBuffer.InsertFromBankAccLedgerEntry(BankAccountLedgerEntry);        until BankAccountLedgerEntry.Next() = 0;        TempBankAccLedgerEntryMatchingBuffer.SetCurrentKey("Posting Date");        TempBankAccLedgerEntryMatchingBuffer.SetAscending("Posting Date", true);    end;    procedure ListOfMatchedFields(AmountMatched: Boolean; DocumentNoMatched: Boolean; ExternalDocumentNoMatched: Boolean; TransactionDateMatched: Boolean; RelatedPartyMatched: Boolean; DescriptionMatched: Boolean): Text    var        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        ListOfFields: Text;        Comma: Text;    begin        Comma := ', ';        if AmountMatched then            ListOfFields += BankAccountLedgerEntry.FieldCaption(BankAccountLedgerEntry."Remaining Amount");        if DocumentNoMatched then begin            if ListOfFields <> '' then                ListOfFields += Comma;            ListOfFields += BankAccountLedgerEntry.FieldCaption(BankAccountLedgerEntry."Document No.");        end;        if ExternalDocumentNoMatched then begin            if ListOfFields <> '' then                ListOfFields += Comma;            ListOfFields += BankAccountLedgerEntry.FieldCaption(BankAccountLedgerEntry."External Document No.");        end;        if TransactionDateMatched then begin            if ListOfFields <> '' then                ListOfFields += Comma;            ListOfFields += BankAccountLedgerEntry.FieldCaption(BankAccountLedgerEntry."Posting Date");        end;        if RelatedPartyMatched or DescriptionMatched then begin            if ListOfFields <> '' then                ListOfFields += Comma;            ListOfFields += BankAccountLedgerEntry.FieldCaption(BankAccountLedgerEntry.Description);        end;        exit(ListOfFields);    end;    procedure SaveOneToOneMatching(var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; BankAccountNo: Code[20]; StatementNo: Code[20])    var        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";        PaymentMatchingDetails: Record "Payment Matching Details";        BankAccEntrySetReconNo: Codeunit "Bank Acc. Entry Set Recon.-No.";    begin        // seems to be only used by auto match        TempBankStatementMatchingBuffer.Reset();        TempBankStatementMatchingBuffer.SetCurrentKey(Quality);        TempBankStatementMatchingBuffer.Ascending(false);        if TempBankStatementMatchingBuffer.FindSet() then            repeat                BankAccountLedgerEntry.Get(TempBankStatementMatchingBuffer."Entry No.");                BankAccReconciliationLine.Get(                  BankAccReconciliationLine."Statement Type"::"Bank Reconciliation",                  BankAccountNo, StatementNo,                  TempBankStatementMatchingBuffer."Line No.");                if BankAccEntrySetReconNo.ApplyEntries(BankAccReconciliationLine, BankAccountLedgerEntry, Relation::"One-to-Many") then                    PaymentMatchingDetails.CreatePaymentMatchingDetail(BankAccReconciliationLine, TempBankStatementMatchingBuffer."Match Details");            until TempBankStatementMatchingBuffer.Next() = 0;    end;    procedure SaveManyToOneMatching(var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; BankAccountNo: Code[20]; StatementNo: Code[20])    var        BankAccountLedgerEntry: Record "Bank Account Ledger Entry";        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";        PaymentMatchingDetails: Record "Payment Matching Details";        TempBankStatementMatchingBufferCopy: Record "Bank Statement Matching Buffer" temporary;        BankAccEntrySetReconNo: Codeunit "Bank Acc. Entry Set Recon.-No.";        LineNoFilterTxt: Text;        LineCount: Integer;        AppliedEntryNumbers: List of [Integer];    begin        TempBankStatementMatchingBuffer.Reset();        if TempBankStatementMatchingBuffer.FindSet() then            repeat                TempBankStatementMatchingBufferCopy.Copy(TempBankStatementMatchingBuffer);                TempBankStatementMatchingBufferCopy.Insert();            until TempBankStatementMatchingBuffer.Next() = 0;        TempBankStatementMatchingBuffer.Reset();        TempBankStatementMatchingBuffer.SetCurrentKey(Quality);        TempBankStatementMatchingBuffer.Ascending(false);        if TempBankStatementMatchingBuffer.FindSet() then            repeat                if not AppliedEntryNumbers.Contains(TempBankStatementMatchingBuffer."Entry No.") then begin                    TempBankStatementMatchingBufferCopy.Reset();                    TempBankStatementMatchingBufferCopy.SetRange("Entry No.", TempBankStatementMatchingBuffer."Entry No.");                    if TempBankStatementMatchingBufferCopy.Count() > 1 then begin                        LineNoFilterTxt := '';                        TempBankStatementMatchingBufferCopy.FindSet();                        repeat                            if LineNoFilterTxt <> '' then                                LineNoFilterTxt += '|';                            LineNoFilterTxt += Format(TempBankStatementMatchingBufferCopy."Line No.");                        until TempBankStatementMatchingBufferCopy.Next() = 0;                        BankAccountLedgerEntry.Get(TempBankStatementMatchingBuffer."Entry No.");                        BankAccReconciliationLine.Reset();                        BankAccReconciliationLine.SetRange("Statement Type", BankAccReconciliationLine."Statement Type"::"Bank Reconciliation");                        BankAccReconciliationLine.SetRange("Bank Account No.", BankAccountNo);                        BankAccReconciliationLine.SetRange("Statement No.", StatementNo);                        BankAccReconciliationLine.SetFilter("Statement Line No.", LineNoFilterTxt);                        LineCount := BankAccReconciliationLine.Count();                        if LineCount > 1 then begin                            BankAccEntrySetReconNo.SetLineCount(LineCount);                            BankAccEntrySetReconNo.SetLineNumber(0);                            BankAccEntrySetReconNo.SetAppliedAmount(0);                            if BankAccReconciliationLine.FindSet() then                                repeat                                    if BankAccEntrySetReconNo.ApplyEntries(BankAccReconciliationLine, BankAccountLedgerEntry, Relation::"Many-to-One") then begin                                        TempBankStatementMatchingBufferCopy.Reset();                                        TempBankStatementMatchingBufferCopy.Get(BankAccReconciliationLine."Statement Line No.", BankAccountLedgerEntry."Entry No.", TempBankStatementMatchingBuffer."Account Type", TempBankStatementMatchingBuffer."Account No.");                                        PaymentMatchingDetails.CreatePaymentMatchingDetail(BankAccReconciliationLine, TempBankStatementMatchingBufferCopy."Match Details");                                    end;                                until BankAccReconciliationLine.Next() = 0;                            AppliedEntryNumbers.Add(TempBankStatementMatchingBuffer."Entry No.");                            TempBankStatementMatchingBuffer.Delete();                        end;                    end;                end else                    TempBankStatementMatchingBuffer.Delete();            until TempBankStatementMatchingBuffer.Next() = 0;    end;    procedure ShowMatchSummary(BankAccReconciliation: Record "Bank Acc. Reconciliation")    var        BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line";        FinalText: Text;        AdditionalText: Text;        TotalCount: Integer;        MatchedCount: Integer;        IsHandled: Boolean;    begin        BankAccReconciliationLine.SetRange("Bank Account No.", BankAccReconciliation."Bank Account No.");        BankAccReconciliationLine.SetRange("Statement Type", BankAccReconciliation."Statement Type");        BankAccReconciliationLine.SetRange("Statement No.", BankAccReconciliation."Statement No.");        TotalCount := BankAccReconciliationLine.Count();        BankAccReconciliationLine.SetFilter("Applied Entries", '<>%1', 0);        MatchedCount := BankAccReconciliationLine.Count();        Session.LogMessage('0000KML', StrSubstNo(BankAccountRecTotalAndMatchedLinesLbl, TotalCount, MatchedCount), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl);        if MatchedCount < TotalCount then            AdditionalText := StrSubstNo(MissingMatchMsg, Format(GetMatchLengthTreshold()));        FinalText := StrSubstNo(MatchSummaryMsg, MatchedCount, TotalCount) + AdditionalText;        IsHandled := false;        OnShowMatchSummaryOnAfterSetFinalText(BankAccReconciliation, FinalText, IsHandled);        if not IsHandled then            Message(FinalText);    end;    procedure GetDescriptionMatchScore(BankRecDescription: Text; BankEntryDescription: Text; DocumentNo: Code[20]; ExternalDocumentNo: Code[35]): Integer    var        RecordMatchMgt: Codeunit "Record Match Mgt.";        Nearness: Integer;        Score: Integer;        MatchLengthTreshold: Integer;        NormalizingFactor: Integer;    begin        BankRecDescription := RecordMatchMgt.Trim(BankRecDescription);        BankEntryDescription := RecordMatchMgt.Trim(BankEntryDescription);        MatchLengthTreshold := GetMatchLengthTreshold();        NormalizingFactor := GetNormalizingFactor();        Score := 0;        Nearness := RecordMatchMgt.CalculateStringNearness(BankRecDescription, DocumentNo,            MatchLengthTreshold, NormalizingFactor);        if Nearness = NormalizingFactor then            Score += 11;        Nearness := RecordMatchMgt.CalculateStringNearness(BankRecDescription, ExternalDocumentNo,            MatchLengthTreshold, NormalizingFactor);        if Nearness = NormalizingFactor then            Score += Nearness;        Nearness := RecordMatchMgt.CalculateStringNearness(BankRecDescription, BankEntryDescription,            MatchLengthTreshold, NormalizingFactor);        if Nearness >= 0.8 * NormalizingFactor then            Score += Nearness;        exit(Score);    end;    procedure SetMatchLengthTreshold(NewMatchLengthThreshold: Integer)    begin        MatchLengthTreshold := NewMatchLengthThreshold;    end;    procedure SetNormalizingFactor(NewNormalizingFactor: Integer)    begin        NormalizingFactor := NewNormalizingFactor;    end;    procedure GetMatchLengthTreshold(): Integer    begin        exit(MatchLengthTreshold);    end;    procedure GetNormalizingFactor(): Integer    begin        exit(NormalizingFactor);    end;    /// <summary>    /// Integration event raised after setting the final text in the match summary display.    /// Allows subscribers to customize the summary text or provide alternative display handling.    /// </summary>    /// <param name="BankAccReconciliation">Bank reconciliation document being summarized.</param>    /// <param name="FinalText">The final summary text that will be displayed to the user.</param>    /// <param name="IsHandled">Set to true if subscriber handles the text display processing.</param>    [IntegrationEvent(false, false)]    local procedure OnShowMatchSummaryOnAfterSetFinalText(var BankAccReconciliation: Record "Bank Acc. Reconciliation"; FinalText: Text; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event for finding best matches using custom algorithms or external services.    /// Allows subscribers to implement alternative matching logic, potentially with AI or machine learning.    /// </summary>    /// <param name="BankAccReconciliationLine">Bank reconciliation line to find matches for.</param>    /// <param name="TempBankAccLedgerEntryMatchingBuffer">Buffer containing potential bank account ledger entry matches.</param>    /// <param name="DaysTolerance">Number of days tolerance for date matching.</param>    /// <param name="TempBankStatementMatchingBuffer">Buffer for storing and ranking matching results.</param>    /// <param name="RemovedPreviouslyAssigned">Indicates if previously assigned matches were removed.</param>    /// <param name="Handled">Set to true if subscriber handles the matching process completely.</param>    [IntegrationEvent(false, false)]    local procedure OnFindBestMatches(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempBankAccLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; DaysTolerance: Integer; var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var RemovedPreviouslyAssigned: Boolean; var Handled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before removing matches from reconciliation lines.    /// Allows subscribers to implement custom removal logic or prevent the removal operation.    /// </summary>    /// <param name="IsHandled">Set to true if subscriber handles the match removal process.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeRemoveMatchesFromRecLines(var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised after removing an application from a bank account ledger entry during match removal.    /// Allows subscribers to perform cleanup operations or additional processing after application removal.    /// </summary>    /// <param name="BankAccountLedgerEntry">Bank account ledger entry from which application was removed.</param>    [IntegrationEvent(false, false)]    local procedure OnRemoveMatchOnAfterRemoveApplication(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry");    begin    end;    /// <summary>    /// Integration event raised before applying entries in a many-to-one matching scenario.    /// Allows subscribers to perform validation or modify data before the many-to-one application.    /// </summary>    /// <param name="BankAccReconciliationLine">Bank reconciliation line being applied to multiple entries.</param>    /// <param name="BankAccountLedgerEntry">One of the bank account ledger entries being matched.</param>    [IntegrationEvent(false, false)]    local procedure OnPerformManyToOneMatchOnBeforeApplyEntries(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var BankAccountLedgerEntry: Record "Bank Account Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised after applying entries in a many-to-one matching scenario.    /// Allows subscribers to perform post-application processing or logging for many-to-one matches.    /// </summary>    /// <param name="BankAccReconciliationLine">Bank reconciliation line that was applied to multiple entries.</param>    /// <param name="BankAccountLedgerEntry">One of the bank account ledger entries that was matched.</param>    [IntegrationEvent(false, false)]    local procedure OnPerformManyToOneMatchOnAfterApplyEntries(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var BankAccountLedgerEntry: Record "Bank Account Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before applying entries in one-to-one or one-to-many matching scenarios.    /// Allows subscribers to perform validation or modify data before the entry application.    /// </summary>    /// <param name="BankAccReconciliationLine">Bank reconciliation line being applied.</param>    /// <param name="BankAccountLedgerEntry">Bank account ledger entry being matched.</param>    [IntegrationEvent(false, false)]    local procedure OnPerformOneToOneOrManyMatchOnBeforeApplyEntries(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var BankAccountLedgerEntry: Record "Bank Account Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised after applying entries in one-to-one or one-to-many matching scenarios.    /// Allows subscribers to perform post-application processing or logging for standard matches.    /// </summary>    /// <param name="BankAccReconciliationLine">Bank reconciliation line that was applied.</param>    /// <param name="BankAccountLedgerEntry">Bank account ledger entry that was matched.</param>    [IntegrationEvent(false, false)]    local procedure OnPerformOneToOneOrManyMatchOnAfterApplyEntries(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var BankAccountLedgerEntry: Record "Bank Account Ledger Entry")    begin    end;}