Codeunit 1255 Match Bank Payments
src/Layers/W1/BaseApp/Bank/Reconciliation/MatchBankPayments.Codeunit.al3,187 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.DirectDebit;using Microsoft.Bank.Ledger;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.HumanResources.Employee;using Microsoft.HumanResources.Payables;using Microsoft.Purchases.Payables;using Microsoft.Purchases.Setup;using Microsoft.Purchases.Vendor;using Microsoft.Sales.Customer;using Microsoft.Sales.Receivables;using Microsoft.Sales.Setup;using System.Environment.Configuration;using System.Telemetry;/// <summary>/// Core engine for automatic matching of bank statement lines to customer, vendor, and general ledger entries./// This codeunit implements sophisticated matching algorithms that analyze transaction amounts, dates, references,/// and party names to automatically apply payments and reconcile bank transactions. Supports configurable matching/// rules, confidence scoring, and multiple application scenarios including one-to-one, one-to-many, and many-to-one matching./// Integrates with payment discount calculations, tolerance handling, and text-to-account mapping./// </summary>/// <remarks>/// Key features include automatic payment application with configurable matching rules, text analysis for party identification,/// amount and date tolerance matching, payment discount support, multi-currency handling, and comprehensive logging./// The codeunit uses scoring algorithms to rank match quality and applies configurable thresholds to determine/// automatic vs. manual application. Integration events enable customization of matching logic and application rules./// Supports both payment reconciliation and bank reconciliation workflows with optimized performance for large volumes./// </remarks>#pragma warning disable AA0198codeunit 1255 "Match Bank Payments"{ Permissions = TableData "Cust. Ledger Entry" = rm, TableData "Vendor Ledger Entry" = rm; TableNo = "Bank Acc. Reconciliation Line"; trigger OnRun() var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; begin BankAccReconciliationLine.Copy(Rec); Code(BankAccReconciliationLine); Rec := BankAccReconciliationLine; OnAfterCode(BankAccReconciliationLine); end; /// <summary> /// Runs the automatic payment matching process without overwriting manual or accepted matches. /// This procedure preserves user decisions while applying automatic matching to unprocessed lines, /// ensuring that manual interventions and accepted applications are not disturbed by automation. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line record set to process for automatic matching.</param> procedure MatchNoOverwriteOfManualOrAccepted(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var BankAccReconciliationLineBackup: Record "Bank Acc. Reconciliation Line"; begin BankAccReconciliationLineBackup.Copy(BankAccReconciliationLine); Code(BankAccReconciliationLineBackup, false); BankAccReconciliationLine := BankAccReconciliationLineBackup; OnAfterCode(BankAccReconciliationLine); end; var BankAccount: Record "Bank Account"; BankPmtApplSettings: Record "Bank Pmt. Appl. Settings"; TempBankPmtApplRule: Record "Bank Pmt. Appl. Rule" temporary; TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary;#pragma warning disable AA0470 TextMapperRulesOverridenTxt: Label '%1 text mapper rules could be applied. They were overridden because a record with the %2 match confidence was found.'; MultipleEntriesWithSilarConfidenceFoundTxt: Label 'There are %1 ledger entries that this statement line could be applied to with the same confidence.'; MultipleStatementLinesWithSameConfidenceFoundTxt: Label 'There are %1 alternative statement lines that could be applied to the same ledger entry with the same confidence.';#pragma warning restore AA0470 CannotFindRuleLbl: Label 'Unexpected - could not find the payment application rule, score %1', Locked = true, Comment = '%1 is the score'; AutomatchEventNameTelemetryTxt: Label 'Automatch', Locked = true; TempOneToManyTempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; TempBankStmtMultipleMatchLine: Record "Bank Stmt Multiple Match Line" temporary; TempCustomerLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; TempVendorLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; TempBankAccLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; TempEmployeeLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; TempDirectDebitCollectionBuffer: Record "Direct Debit Collection Buffer" temporary; BankPmtApplSettingsInitialized: Boolean; ApplyEntries: Boolean; CandidateFilterReferenceDate: Date;#pragma warning disable AA0470 CannotApplyDocumentNoOneToManyApplicationTxt: Label 'Document No. %1 was not applied because the transaction amount was insufficient.';#pragma warning restore AA0470 UsePaymentDiscounts: Boolean; MinimumMatchScore: Integer; RelatedPartyMatchedInfoText: Text; DocumentMatchedInfoText: Text; LogInfoText: Boolean; MatchSummaryMsg: Label '%1 payment lines out of %2 are applied.\\', Comment = '%1 number of lines that are applied, %2 total number of lines';#pragma warning disable AA0470 MatchingStmtLinesMsg: Label 'The matching of statement lines to open ledger entries is in progress.\\Please wait while the operation is being completed.\\#1####### @2@@@@@@@@@@@@@'; ProcessedStmtLinesMsg: Label 'Processed %1 out of %2 lines.';#pragma warning restore AA0470 CreatingAppliedEntriesMsg: Label 'The application of statement lines to open ledger entries is in progress. Please wait while the operation is being completed.'; ProgressBarMsg: Label 'Please wait while the operation is being completed.'; MustChooseAccountErr: Label 'You must choose an account to transfer the difference to.'; LineSplitTxt: Label 'The value in the Transaction Amount field has been reduced by %1. A new line with %1 in the Transaction Amount field has been created.', Comment = '%1 - Difference'; BankAccountRecCategoryLbl: Label 'AL Payment Reconciliation', Locked = true; BankAccountRecTotalAndMatchedLinesLbl: Label 'Total Bank Statement Lines: %1, of those applied: %2, and text-matched: %3', Locked = true; MatchedRelatedPartyOnBankAccountMsg: Label 'The related party was matched based on the bank account in the statement file.'; MatchedRelatedPartyOnBankStatementInfoMsg: Label 'The related party was matched based on the %1 in the statement file.', Comment = '%1 is the name of the fields used, e.g. Address, Name...'; TextPartialMatchMsg: Label '%1 was matched with %2% accuracy.', Comment = '%1 is the name of the field, %2 is percent'; RelatedPartyNameIsUniqueMsg: Label 'The name of the related party is unique in your records.'; ExternalDocumentNumberMatchedInTransactionTextMsg: Label 'We found a match for the external document number in the transaction text.'; DocumentNumberMatchedInTransactionTextMsg: Label 'We found a match for the document number in the transaction text.'; DocumentNumberMatchedByPaymentReferenceMsg: Label 'We matched the document number by using the payment reference.'; NewLinePlaceholderLbl: Label '%1%2', Locked = true; RelatedPartyMatchInfoPlaceholderLbl: Label '%1, %2, %3', Locked = true; PaymentRecPreformanceCategoryLbl: Label 'PaymentRecPerformance', Locked = true; MatchedLineTelemetryTxt: Label 'Line with SystemId: %1 Matched, Total Time: %2. Total time Customer Matching %3, Total time Vendor Matching: %4, Total time Employee Matching: %5,Total time Bank Ledger Entries: %6, Total Time TextMappings: %7', Locked = true; AppliedEntriesToBankStatementLineTxt: Label 'Line with SystemId: %1 - Applied entries - Account Type: %2, One-To-Many match: %3, Match Quality: %4.', Locked = true; SpecificTaskSummaryTxt: Label 'Specific Task Summary: TotalTimeDirectCollection: %1, TotalTimeRelatedPartyMatching: %2, TotalTimeDocumentNoMatching: %3, TotalTimeAmountMatching: %4, TotalTimeStringNearness: %5, TotalTimeDocumentNoMatchingForBankLedgerEntry: %6, TotalTimeSearchingDocumentNoInLedgerEntries: %7, HitCountClosingDocumentMatches: %8 out of %9', Locked = true; MissingRelatedPartyTelemetryMsg: Label 'The ledger entries contain the entries that do not exist in master data. This is indication of corrupted ledger entries. Master data type %1.', Locked = true, Comment = '%1 Master Data Type'; PmtRecNoSeriesNotificationNameLbl: Label 'Payment reconciliation journals need a number series.'; PmtRecNoSeriesNotificationDescriptionLbl: Label 'Notifies the user that payment reconciliation journals are not assigned to a number series.'; EntriesMatchedElsewhereMsg: Label 'There are open %1 ledger entries applied in other journals. The entries were not considered in the automatic application. To consider these entries, unapply them first from the other journals.', Comment = '%1 - either "customer", "vendor" or "employee".'; DontShowAgainTxt: Label 'Don''t show again.'; TotalTimeMatchingCustomerLedgerEntriesPerLine: Duration; TotalTimeMatchingVendorLedgerEntriesPerLine: Duration; TotalTimeMatchingEmployeeLedgerEntriesPerLine: Duration; TotalTimeMatchingBankLedgerEntriesPerLine: Duration; TotalTimeTimeTextMappingsPerLine: Duration; TotalTimeDirectCollection: Duration; TotalTimeRelatedPartyMatching: Duration; TotalTimeDocumentNoMatching: Duration; TotalTimeAmountMatching: Duration; TotalTimeStringNearness: Duration; TotalTimeDocumentNoMatchingForBankLedgerEntry: Duration; TotalTimeSearchingDocumentNoInLedgerEntries: Duration; BankLedgerEntriesClosingDocumentNumbers: Dictionary of [Integer, List of [Code[35]]]; MissingDataTypeTelemetrySent: List of [Integer]; TotalNoClosingDocumentMatches: Integer; HitCountClosingDocumentMatches: Integer; /// <summary> /// Determines whether a bank statement line is mapped using text-to-account mapping rules. /// Checks if the line was automatically matched using predefined text patterns and retrieves /// the applicable mapping rules if found. Used to identify and process text-based automatic applications. /// </summary> /// <param name="BankAccReconciliaitonLine">Bank reconciliation line to check for text-to-account mapping.</param> /// <param name="TempTextToAccMapping">Temporary table to receive applicable text-to-account mapping rules.</param> /// <returns>True if the line uses text-to-account mapping; false otherwise.</returns> procedure IsTextToAccountMappig( BankAccReconciliaitonLine: Record "Bank Acc. Reconciliation Line"; var TempTextToAccMapping: Record "Text-to-Account Mapping" temporary ): Boolean var IsMapToTextAccount: Boolean; begin IsMapToTextAccount := BankAccReconciliaitonLine."Match Confidence" = BankAccReconciliaitonLine."Match Confidence"::"High - Text-to-Account Mapping"; if IsMapToTextAccount then FindApplicableTextMappings(BankAccReconciliaitonLine, TempTextToAccMapping); exit(IsMapToTextAccount); end; /// <summary> /// Determines whether a bank statement line was matched automatically based on payment application rules. /// Evaluates match confidence and applied entries count against configured automatic application thresholds, /// retrieving the specific rule that enabled automatic matching for audit and processing purposes. /// </summary> /// <param name="BankAccReconciliaitonLine">Bank reconciliation line to check for automatic matching status.</param> /// <param name="BankPmtApplRule">Returns the payment application rule that enabled automatic matching.</param> /// <returns>True if the line was matched automatically; false if manual intervention was required.</returns> procedure IsMatchedAutomatically( BankAccReconciliaitonLine: Record "Bank Acc. Reconciliation Line"; var BankPmtApplRule: Record "Bank Pmt. Appl. Rule" ): Boolean var IsAutoMatch: Boolean; MatchingRuleFound: Boolean; begin IsAutoMatch := BankPmtApplRule.IsMatchedAutomatically(BankAccReconciliaitonLine."Match Confidence".AsInteger(), BankAccReconciliaitonLine."Applied Entries"); if IsAutoMatch or (BankAccReconciliaitonLine."Match Confidence" = BankAccReconciliaitonLine."Match Confidence"::Accepted) then begin BankPmtApplRule.SetRange(Score, BankAccReconciliaitonLine."Match Quality"); MatchingRuleFound := BankPmtApplRule.FindFirst(); if not MatchingRuleFound and IsAutoMatch then Session.LogMessage('0000BN6', StrSubstNo(CannotFindRuleLbl, BankAccReconciliaitonLine."Match Quality"), Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl); IsAutoMatch := MatchingRuleFound; BankPmtApplRule.SetRange(Score); end; exit(IsAutoMatch); end; /// <summary> /// Retrieves comprehensive matching details for payment application analysis and reporting. /// Analyzes the bank statement line and its matching entries to provide detailed information about /// how the automatic payment application was performed, including related party matching, amount /// tolerance analysis, document number matching, and direct debit correlation. Used by UI components /// to display matching confidence details and help users understand application decisions. /// </summary> /// <param name="BankAccReconciliaitonLine">Bank reconciliation line to analyze for matching details.</param> /// <param name="BankPmtApplRule">Payment application rule used for the matching process.</param> /// <param name="MatchedAutomatically">Indicates whether the line was matched automatically or manually.</param> /// <param name="RelatedPartyMatchedText">Returns text describing how related party matching was performed.</param> /// <param name="AmountMatchText">Returns text describing amount matching results and tolerance application.</param> /// <param name="DocumentMatchedText">Returns text describing document number matching results.</param> /// <param name="DirectDebitMatchedText">Returns text describing direct debit matching correlation.</param> /// <param name="DirectDebitMatched">Returns whether direct debit correlation was found.</param> /// <param name="NoOfLedgerEntriesWithinAmountTolerance">Returns count of ledger entries within amount tolerance.</param> /// <param name="NoOfLedgerEntriesOutsideAmountTolerance">Returns count of ledger entries outside amount tolerance.</param> /// <param name="RelatedEntryAdditionalMatchInfo">Returns additional information about related entry matching.</param> /// <param name="DocumentNoAdditionalMatchInfo">Returns additional information about document number matching.</param> procedure GetMatchPaymentDetailsInfo( BankAccReconciliaitonLine: Record "Bank Acc. Reconciliation Line"; BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; MatchedAutomatically: Boolean; var RelatedPartyMatchedText: Text; var AmountMatchText: Text; var DocumentMatchedText: Text; var DirectDebitMatchedText: Text; var DirectDebitMatched: Boolean; var NoOfLedgerEntriesWithinAmountTolerance: Integer; var NoOfLedgerEntriesOutsideAmountTolerance: Integer; var RelatedEntryAdditionalMatchInfo: Text; var DocumentNoAdditionalMatchInfo: Text ) var ActualBankPmtApplRule: Record "Bank Pmt. Appl. Rule"; TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; MinAmount: Decimal; MaxAmount: Decimal; RemainingAmount: Decimal; TempLedgerEntryFound: Boolean; AppliesToEntriesFilter: Text; begin BankAccReconciliaitonLine.GetAmountRangeForTolerance(MinAmount, MaxAmount); case BankAccReconciliaitonLine."Account Type" of BankAccReconciliaitonLine."Account Type"::Customer: begin if TempCustomerLedgerEntryMatchingBuffer.IsEmpty() then InitializeCustomerLedgerEntriesMatchingBuffer(BankAccReconciliaitonLine, TempCustomerLedgerEntryMatchingBuffer); NoOfLedgerEntriesWithinAmountTolerance := TempCustomerLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange(MinAmount, MaxAmount, BankAccReconciliaitonLine."Transaction Date", UsePaymentDiscounts); NoOfLedgerEntriesOutsideAmountTolerance := TempCustomerLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesOutsideRange(MinAmount, MaxAmount, BankAccReconciliaitonLine."Transaction Date", UsePaymentDiscounts); TempLedgerEntryMatchingBuffer.Copy(TempCustomerLedgerEntryMatchingBuffer, true); end; BankAccReconciliaitonLine."Account Type"::Vendor: begin if TempVendorLedgerEntryMatchingBuffer.IsEmpty() then InitializeVendorLedgerEntriesMatchingBuffer(BankAccReconciliaitonLine, TempVendorLedgerEntryMatchingBuffer); NoOfLedgerEntriesWithinAmountTolerance := TempVendorLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange(MinAmount, MaxAmount, BankAccReconciliaitonLine."Transaction Date", UsePaymentDiscounts); NoOfLedgerEntriesOutsideAmountTolerance := TempVendorLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesOutsideRange(MinAmount, MaxAmount, BankAccReconciliaitonLine."Transaction Date", UsePaymentDiscounts); TempLedgerEntryMatchingBuffer.Copy(TempVendorLedgerEntryMatchingBuffer, true); end; BankAccReconciliaitonLine."Account Type"::"Bank Account": begin if TempBankAccLedgerEntryMatchingBuffer.IsEmpty() then InitializeBankAccLedgerEntriesMatchingBuffer(BankAccReconciliaitonLine, TempBankAccLedgerEntryMatchingBuffer); NoOfLedgerEntriesWithinAmountTolerance := TempBankAccLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange(MinAmount, MaxAmount, BankAccReconciliaitonLine."Transaction Date", UsePaymentDiscounts); NoOfLedgerEntriesOutsideAmountTolerance := TempBankAccLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesOutsideRange(MinAmount, MaxAmount, BankAccReconciliaitonLine."Transaction Date", UsePaymentDiscounts); TempLedgerEntryMatchingBuffer.Copy(TempBankAccLedgerEntryMatchingBuffer, true); end; end; if not MatchedAutomatically then exit; TempLedgerEntryFound := false; AppliesToEntriesFilter := BankAccReconciliaitonLine.GetAppliedToEntryFilter(); if AppliesToEntriesFilter <> '' then begin TempLedgerEntryMatchingBuffer.SetFilter("Entry No.", StrSubstNo('=%1', AppliesToEntriesFilter)); TempLedgerEntryFound := TempLedgerEntryMatchingBuffer.FindFirst(); end; LogInfoText := true; if TempLedgerEntryFound then MatchEntries(TempLedgerEntryMatchingBuffer, BankAccReconciliaitonLine, BankAccReconciliaitonLine."Account Type", ActualBankPmtApplRule, RemainingAmount) else begin Session.LogMessage('0000BN7', StrSubstNo( 'Could not find the Temp Ledger Entry - Filter %1, Account Type %2', BankAccReconciliaitonLine.GetAppliedToEntryFilter(), BankAccReconciliaitonLine."Account Type"), Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl); ActualBankPmtApplRule := BankPmtApplRule; end; AmountMatchText := Format(ActualBankPmtApplRule."Amount Incl. Tolerance Matched"); RelatedPartyMatchedText := Format(ActualBankPmtApplRule."Related Party Matched"); RelatedEntryAdditionalMatchInfo := RelatedPartyMatchedInfoText; DocumentNoAdditionalMatchInfo := DocumentMatchedInfoText; DocumentMatchedText := Format(ActualBankPmtApplRule."Doc. No./Ext. Doc. No. Matched"); DirectDebitMatchedText := Format(ActualBankPmtApplRule."Direct Debit Collect. Matched"); DirectDebitMatched := ActualBankPmtApplRule."Direct Debit Collect. Matched" = ActualBankPmtApplRule."Direct Debit Collect. Matched"::Yes; end; /// <summary> /// Executes the complete payment matching process for bank reconciliation lines. /// Maps ledger entries to statement lines using configured matching rules and optionally applies /// the matched entries to create payment applications. Supports selective overwriting based on /// the Overwrite parameter to preserve manual matching decisions. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line record set to process for payment matching.</param> /// <param name="Overwrite">True to overwrite existing matches including manual and accepted; false to preserve them.</param> procedure "Code"(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; Overwrite: Boolean) begin if BankAccReconciliationLine.IsEmpty() then exit; MapLedgerEntriesToStatementLines(BankAccReconciliationLine, Overwrite, ApplyEntries); if ApplyEntries then begin ApplyLedgerEntriesToStatementLines(BankAccReconciliationLine, Overwrite); NotifyIfEntriesMatchedElsewhere(BankAccReconciliationLine); end; end; /// <summary> /// Executes the complete payment matching process with default overwrite behavior. /// This overload calls the main Code procedure with Overwrite set to true, allowing /// the matching process to override existing manual and accepted matches. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line record set to process for payment matching.</param> procedure "Code"(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin Code(BankAccReconciliationLine, true); end; local procedure NotifyIfEntriesMatchedElsewhere(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var CustLedgerEntry: Record "Cust. Ledger Entry"; VendorLedgerEntry: Record "Vendor Ledger Entry"; EmployeeLedgerEntry: Record "Employee Ledger Entry"; Prefix: Code[50]; MaxEntriesToCheck: Integer; IsHandled: Boolean; begin IsHandled := false; OnBeforeNotifyIfEntriesMatchedElsewhere(BankAccReconciliationLine, IsHandled); if IsHandled then exit; if not GuiAllowed() then exit; MaxEntriesToCheck := 600; Prefix := BankAccReconciliationLine.GetAppliesToIDForBankStatement(); CustLedgerEntry.SetRange(Open, true); CustLedgerEntry.SetFilter("Applies-to ID", '<>%1', ''); if CustLedgerEntry.Count() < MaxEntriesToCheck then if CustLedgerEntry.FindSet() then repeat if CopyStr(CustLedgerEntry."Applies-to ID", 1, StrLen(Prefix)) <> Prefix then begin LaunchEntriesMatchedElsewhereNotification('customer'); exit; end; until CustLedgerEntry.Next() = 0; VendorLedgerEntry.SetRange(Open, true); VendorLedgerEntry.SetFilter("Applies-to ID", '<>%1', ''); if VendorLedgerEntry.Count() < MaxEntriesToCheck then if VendorLedgerEntry.FindSet() then repeat if CopyStr(VendorLedgerEntry."Applies-to ID", 1, StrLen(Prefix)) <> Prefix then begin LaunchEntriesMatchedElsewhereNotification('vendor'); exit; end; until VendorLedgerEntry.Next() = 0; EmployeeLedgerEntry.SetRange(Open, true); EmployeeLedgerEntry.SetFilter("Applies-to ID", '<>%1', ''); if EmployeeLedgerEntry.Count() < MaxEntriesToCheck then if EmployeeLedgerEntry.FindSet() then repeat if CopyStr(EmployeeLedgerEntry."Applies-to ID", 1, StrLen(Prefix)) <> Prefix then begin LaunchEntriesMatchedElsewhereNotification('employee'); exit; end; until EmployeeLedgerEntry.Next() = 0; end; local procedure LaunchEntriesMatchedElsewhereNotification(Entity: Text) var MyNotifications: Record "My Notifications"; Notification: Notification; begin if not MyNotifications.IsEnabled(EntriesMatchedElsewhereNotificationId()) then exit; Notification.Id := EntriesMatchedElsewhereNotificationId(); Notification.Message := StrSubstNo(EntriesMatchedElsewhereMsg, Entity); Notification.Scope := NotificationScope::LocalScope; Notification.AddAction(DontShowAgainTxt, Codeunit::"Match Bank Payments", 'HideEntriesMatchedElsewhereNotification'); Notification.Send(); end; internal procedure HideEntriesMatchedElsewhereNotification(Notification: Notification) var MyNotifications: Record "My Notifications"; begin if not MyNotifications.Disable(EntriesMatchedElsewhereNotificationId()) then MyNotifications.InsertDefault(EntriesMatchedElsewhereNotificationId(), 'name', 'desc', false); end; local procedure EntriesMatchedElsewhereNotificationId(): Guid begin exit('625601f1-689d-456f-9966-6756420215e0'); end; internal procedure DisableNotification(var MyNotification: Notification) var MyNotifications: Record "My Notifications"; begin if MyNotification.Id <> GetNumberSeriesNotificationId() then exit; MyNotifications.InsertDefault(MyNotification.Id, PmtRecNoSeriesNotificationNameLbl, PmtRecNoSeriesNotificationDescriptionLbl, false); MyNotifications.Disable(MyNotification.Id) end; internal procedure OpenBankAccountCard(var MyNotification: Notification) var LocalBankAccount: Record "Bank Account"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; begin if MyNotification.Id <> GetNumberSeriesNotificationId() then exit; if not LocalBankAccount.Get(MyNotification.GetData(BankAccReconciliationLine.FieldName("Bank Account No."))) then exit; Page.Run(Page::"Bank Account Card", LocalBankAccount, LocalBankAccount."Pmt. Rec. No. Series"); end; /// <summary> /// Gets the unique identifier for payment reconciliation number series notifications. /// Returns a fixed GUID used to identify notifications related to missing number series /// configuration for payment reconciliation journals. /// </summary> /// <returns>GUID identifier for number series notifications.</returns> internal procedure GetNumberSeriesNotificationId(): Guid begin exit('76d60ad7-20a5-4b64-b160-f059e1c7ab2d'); end; /// <summary> /// Opens the Payment Application Review page for bank reconciliation lines requiring manual review. /// Extracts reconciliation data from the notification and filters lines based on the review score /// criteria to display only lines that need user attention for manual application decisions. /// </summary> /// <param name="ReviewNotification">Notification containing bank account, statement details, and review filter criteria.</param> procedure OpenLinesForReviewPage(ReviewNotification: Notification) var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; begin Evaluate(BankAccReconciliationLine."Statement Type", ReviewNotification.GetData(BankAccReconciliationLine.FieldName("Statement Type"))); BankAccReconciliationLine.SetRange("Statement Type", BankAccReconciliationLine."Statement Type"); BankAccReconciliationLine.SetRange("Statement No.", ReviewNotification.GetData(BankAccReconciliationLine.FieldName("Statement No."))); BankAccReconciliationLine.SetRange("Bank Account No.", ReviewNotification.GetData(BankAccReconciliationLine.FieldName("Bank Account No."))); if not BankAccReconciliationLine.FindFirst() then exit; GetLinesForReview(BankAccReconciliationLine, ReviewNotification.GetData('ReviewScoreFilter')); Page.Run(Page::"Payment Application Review", BankAccReconciliationLine); end; /// <summary> /// Opens the Payment Application Review page for bank reconciliation lines with amount differences. /// Extracts reconciliation data from the notification and filters lines to show only those with /// unresolved differences that require user review and manual resolution. /// </summary> /// <param name="ReviewNotification">Notification containing bank account and statement identification details.</param> procedure OpenLinesWithDifferencePage(ReviewNotification: Notification) var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; begin Evaluate(BankAccReconciliationLine."Statement Type", ReviewNotification.GetData(BankAccReconciliationLine.FieldName("Statement Type"))); BankAccReconciliationLine.SetRange("Statement Type", BankAccReconciliationLine."Statement Type"); BankAccReconciliationLine.SetRange("Statement No.", ReviewNotification.GetData(BankAccReconciliationLine.FieldName("Statement No."))); BankAccReconciliationLine.SetRange("Bank Account No.", ReviewNotification.GetData(BankAccReconciliationLine.FieldName("Bank Account No."))); if not BankAccReconciliationLine.FindFirst() then exit; GetLinesWithDifference(BankAccReconciliationLine); Page.Run(Page::"Payment Application Review", BankAccReconciliationLine); end; /// <summary> /// Filters bank reconciliation lines to include only those requiring manual review. /// Applies match quality and confidence filters to identify lines that were automatically /// matched but need user validation based on the specified review score criteria. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line record set to filter for review requirements.</param> /// <param name="ReviewScoreFilter">Filter criteria for match quality scores that require review.</param> procedure GetLinesForReview(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; ReviewScoreFilter: Text) begin if BankAccReconciliationLine.IsEmpty() then exit; BankAccReconciliationLine.SetFilter("Match Quality", ReviewScoreFilter); BankAccReconciliationLine.SetFilter("Match Confidence", BankAccReconciliationLine.GetMatchedAutomaticallyFilter()); end; /// <summary> /// Filters bank reconciliation lines to include only those with unresolved amount differences. /// Sets a filter to display lines where the difference field is not zero, indicating that /// the applied amount does not fully match the statement amount and requires attention. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line record set to filter for difference handling.</param> procedure GetLinesWithDifference(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin BankAccReconciliationLine.SetFilter(Difference, '<>0'); end; local procedure ApplyLedgerEntriesToStatementLines(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; Overwrite: Boolean) var BankAccReconciliation: Record "Bank Acc. Reconciliation"; FeatureTelemetry: Codeunit "Feature Telemetry"; Window: Dialog; begin FeatureTelemetry.LogUptake('0000KMM', BankAccReconciliation.GetPaymentRecJournalTelemetryFeatureName(), Enum::"Feature Uptake Status"::Used); Window.Open(CreatingAppliedEntriesMsg); BankAccReconciliation.Get( BankAccReconciliationLine."Statement Type", BankAccReconciliationLine."Bank Account No.", BankAccReconciliationLine."Statement No."); DeleteAppliedPaymentEntries(BankAccReconciliation, Overwrite); DeletePaymentMatchDetails(BankAccReconciliation); CreateAppliedEntries(BankAccReconciliation); if not Overwrite then BankAccReconciliationLine.SetFilter("Match Confidence", '<>%1&<>%2', BankAccReconciliationLine."Match Confidence"::Accepted, BankAccReconciliationLine."Match Confidence"::Manual); UpdatePaymentMatchDetails(BankAccReconciliationLine); OnApplyLedgerEntriesToStatementLinesOnAfterUpdatePaymentMatchDetails(BankAccReconciliation, BankAccReconciliationLine, Overwrite); Window.Close(); ShowMatchSummary(BankAccReconciliation); FeatureTelemetry.LogUsage('0000KMN', BankAccReconciliation.GetPaymentRecJournalTelemetryFeatureName(), AutomatchEventNameTelemetryTxt); end; local procedure MapLedgerEntriesToStatementLines(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; Overwrite: Boolean; ApplyEntries: Boolean) var BankAccReconciliationLine2: Record "Bank Acc. Reconciliation Line"; Window: Dialog; TotalNoOfLines: Integer; ProcessedLines: Integer; LineStartTime: DateTime; StartTime: DateTime; TimeCustomerLedgerEntries: Duration; TimeVendorLedgerEntries: Duration; TimeEmployeeLedgerEntries: Duration; TimeBankLedgerEntries: Duration; TimeTextMappings: Duration; DisableBankLedgerEntriesMatch: Boolean; DisableCustomerLedgerEntriesMatch: Boolean; DisableVendorLedgerEntriesMatch: Boolean; DisableEmployeeLedgerEntriesMatch: Boolean; SkipOtherEntries: Boolean; begin CandidateFilterReferenceDate := 0D; TempBankStatementMatchingBuffer.Reset(); TempBankStatementMatchingBuffer.DeleteAll(); TempCustomerLedgerEntryMatchingBuffer.DeleteAll(); TempVendorLedgerEntryMatchingBuffer.DeleteAll(); TempBankAccLedgerEntryMatchingBuffer.DeleteAll(); TempDirectDebitCollectionBuffer.DeleteAll(); TempBankPmtApplRule.LoadRules(); MinimumMatchScore := GetLowestMatchScore(); InitializeBankPmtApplSettings(); DisableCustomerLedgerEntriesMatch := not BankPmtApplSettings."Cust. Ledger Entries Matching"; DisableVendorLedgerEntriesMatch := not BankPmtApplSettings."Vendor Ledger Entries Matching"; DisableBankLedgerEntriesMatch := not BankPmtApplSettings."Bank Ledger Entries Matching"; DisableEmployeeLedgerEntriesMatch := not BankPmtApplSettings."Empl. Ledger Entries Matching"; BankAccReconciliationLine.SetFilter("Statement Amount", '<>0'); if not Overwrite then BankAccReconciliationLine.SetFilter("Match Confidence", '<>%1&<>%2', BankAccReconciliationLine."Match Confidence"::Accepted, BankAccReconciliationLine."Match Confidence"::Manual); if BankAccReconciliationLine.FindSet() then begin BankAccReconciliationLine2.CopyFilters(BankAccReconciliationLine); BankAccReconciliationLine2.SetCurrentKey("Transaction Date"); BankAccReconciliationLine2.SetAscending("Transaction Date", true); if BankAccReconciliationLine2.FindFirst() then CandidateFilterReferenceDate := BankAccReconciliationLine2."Transaction Date"; OnDisableCustomerLedgerEntriesMatch(DisableCustomerLedgerEntriesMatch, BankAccReconciliationLine); OnDisableVendorLedgerEntriesMatch(DisableVendorLedgerEntriesMatch, BankAccReconciliationLine); OnDisableEmployeeLedgerEntriesMatch(DisableEmployeeLedgerEntriesMatch, BankAccReconciliationLine); OnDisableBankLedgerEntriesMatch(DisableBankLedgerEntriesMatch, BankAccReconciliationLine); if not DisableCustomerLedgerEntriesMatch then InitializeCustomerLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempCustomerLedgerEntryMatchingBuffer, ApplyEntries); if not DisableVendorLedgerEntriesMatch then InitializeVendorLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempVendorLedgerEntryMatchingBuffer, ApplyEntries); if not DisableBankLedgerEntriesMatch then InitializeBankAccLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempBankAccLedgerEntryMatchingBuffer, ApplyEntries); if not DisableEmployeeLedgerEntriesMatch then InitializeEmployeeLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempEmployeeLedgerEntryMatchingBuffer, ApplyEntries); InitializeDirectDebitCollectionEntriesMatchingBuffer(TempDirectDebitCollectionBuffer); if not Overwrite then RemoveAppliedEntriesFromBufferTables(); TotalNoOfLines := BankAccReconciliationLine.Count(); ProcessedLines := 0; if ApplyEntries then Window.Open(MatchingStmtLinesMsg) else Window.Open(ProgressBarMsg); repeat StartTime := CurrentDateTime(); LineStartTime := StartTime; if not DisableCustomerLedgerEntriesMatch then FindMatchingEntries( BankAccReconciliationLine, TempCustomerLedgerEntryMatchingBuffer, TempBankStatementMatchingBuffer."Account Type"::Customer, SkipOtherEntries); TimeCustomerLedgerEntries := CurrentDateTime() - StartTime; TotalTimeMatchingCustomerLedgerEntriesPerLine += TimeCustomerLedgerEntries; StartTime := CurrentDateTime(); if (not DisableVendorLedgerEntriesMatch) and (not SkipOtherEntries) then FindMatchingEntries( BankAccReconciliationLine, TempVendorLedgerEntryMatchingBuffer, TempBankStatementMatchingBuffer."Account Type"::Vendor, SkipOtherEntries); TimeVendorLedgerEntries := CurrentDateTime() - StartTime; TotalTimeMatchingVendorLedgerEntriesPerLine += TimeVendorLedgerEntries; StartTime := CurrentDateTime(); if (not DisableEmployeeLedgerEntriesMatch) and (not SkipOtherEntries) then FindMatchingEntries( BankAccReconciliationLine, TempEmployeeLedgerEntryMatchingBuffer, TempBankStatementMatchingBuffer."Account Type"::Employee, SkipOtherEntries); TimeEmployeeLedgerEntries := CurrentDateTime() - StartTime; TotalTimeMatchingEmployeeLedgerEntriesPerLine += TimeEmployeeLedgerEntries; StartTime := CurrentDateTime(); if (not DisableBankLedgerEntriesMatch) and (not SkipOtherEntries) then FindMatchingEntries( BankAccReconciliationLine, TempBankAccLedgerEntryMatchingBuffer, TempBankStatementMatchingBuffer."Account Type"::"Bank Account", SkipOtherEntries); TimeBankLedgerEntries := CurrentDateTime() - StartTime; TotalTimeMatchingBankLedgerEntriesPerLine += TimeBankLedgerEntries; StartTime := CurrentDateTime(); FindTextMappings(BankAccReconciliationLine); TimeTextMappings := CurrentDateTime() - StartTime; TotalTimeTimeTextMappingsPerLine += TimeTextMappings; OnMapLedgerEntriesToStatementLinesOnAfterCalcTotalTimeTimeTextMappingsPerLine( BankAccReconciliationLine, TempBankStatementMatchingBuffer, TotalTimeMatchingCustomerLedgerEntriesPerLine, TotalTimeMatchingVendorLedgerEntriesPerLine, TotalTimeMatchingEmployeeLedgerEntriesPerLine, TotalTimeMatchingBankLedgerEntriesPerLine, RelatedPartyMatchedInfoText, LogInfoText, TotalTimeStringNearness, UsePaymentDiscounts, TempOneToManyTempBankStatementMatchingBuffer, TempCustomerLedgerEntryMatchingBuffer, TempVendorLedgerEntryMatchingBuffer, TempEmployeeLedgerEntryMatchingBuffer, TempBankAccLedgerEntryMatchingBuffer); ProcessedLines += 1; Session.LogMessage('0000DK9', StrSubstNo(MatchedLineTelemetryTxt, BankAccReconciliationLine.SystemId, CurrentDateTime() - LineStartTime, TimeCustomerLedgerEntries, TimeVendorLedgerEntries, TimeEmployeeLedgerEntries, TimeBankLedgerEntries, TimeTextMappings), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', PaymentRecPreformanceCategoryLbl); if ApplyEntries then begin Window.Update(1, StrSubstNo(ProcessedStmtLinesMsg, ProcessedLines, TotalNoOfLines)); Window.Update(2, Round(ProcessedLines / TotalNoOfLines * 10000, 1)); end; until BankAccReconciliationLine.Next() = 0; UpdateOneToManyMatches(BankAccReconciliationLine); Session.LogMessage('0000DKD', StrSubstNo(SpecificTaskSummaryTxt, TotalTimeDirectCollection, TotalTimeRelatedPartyMatching, TotalTimeDocumentNoMatching, TotalTimeAmountMatching, TotalTimeStringNearness, TotalTimeDocumentNoMatchingForBankLedgerEntry, TotalTimeSearchingDocumentNoInLedgerEntries, HitCountClosingDocumentMatches, TotalNoClosingDocumentMatches), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', PaymentRecPreformanceCategoryLbl); Window.Close(); end; CandidateFilterReferenceDate := 0D; end; local procedure RemoveAppliedEntriesFromBufferTables() begin RemoveAppliedEntriesFromTempLEMatchingBuffer(TempCustomerLedgerEntryMatchingBuffer); RemoveAppliedEntriesFromTempLEMatchingBuffer(TempVendorLedgerEntryMatchingBuffer); RemoveAppliedEntriesFromTempLEMatchingBuffer(TempBankAccLedgerEntryMatchingBuffer); RemoveAppliedEntriesFromTempLEMatchingBuffer(TempEmployeeLedgerEntryMatchingBuffer); RemoveAppliedEntriesFromDirectDebMatchingBuffer(TempDirectDebitCollectionBuffer); end; local procedure RemoveAppliedEntriesFromTempLEMatchingBuffer(var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary) var AppliedPaymentEntry: Record "Applied Payment Entry"; EntryNo: Integer; begin AppliedPaymentEntry.SetFilter("Match Confidence", '%1|%2', AppliedPaymentEntry."Match Confidence"::Accepted, AppliedPaymentEntry."Match Confidence"::Manual); if AppliedPaymentEntry.FindSet() then repeat EntryNo := AppliedPaymentEntry."Applies-to Entry No."; TempLedgerEntryMatchingBuffer.SetRange("Entry No.", EntryNo); TempLedgerEntryMatchingBuffer.DeleteAll(); until AppliedPaymentEntry.Next() = 0 end; local procedure RemoveAppliedEntriesFromDirectDebMatchingBuffer(var TempDirectDebitCollectionEntryBuffer: Record "Direct Debit Collection Buffer" temporary) var AppliedPaymentEntry: Record "Applied Payment Entry"; EntryNo: Integer; begin AppliedPaymentEntry.SetFilter("Match Confidence", '%1|%2', AppliedPaymentEntry."Match Confidence"::Accepted, AppliedPaymentEntry."Match Confidence"::Manual); if AppliedPaymentEntry.FindSet() then repeat EntryNo := AppliedPaymentEntry."Applies-to Entry No."; TempDirectDebitCollectionEntryBuffer.SetRange("Entry No.", EntryNo); TempDirectDebitCollectionEntryBuffer.DeleteAll(); until AppliedPaymentEntry.Next() = 0 end; /// <summary> /// Re-executes text-to-account mapping for bank reconciliation lines that haven't been manually accepted. /// This procedure reapplies text mapping rules to identify better automatic matches, particularly useful /// after updating mapping rules or when initial matching was incomplete. Preserves accepted and high-confidence matches. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line record set to reprocess with text mapper.</param> procedure RerunTextMapper(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var AppliedPaymentEntry: Record "Applied Payment Entry"; BankAccReconciliation: Record "Bank Acc. Reconciliation"; begin if BankAccReconciliationLine.IsEmpty() then exit; BankAccReconciliationLine.SetRange("Statement Type", BankAccReconciliationLine."Statement Type"::"Payment Application"); BankAccReconciliationLine.SetRange("Bank Account No.", BankAccReconciliationLine."Bank Account No."); BankAccReconciliationLine.SetRange("Statement No.", BankAccReconciliationLine."Statement No."); BankAccReconciliationLine.SetFilter("Match Confidence", '<>%1 & <>%2', BankAccReconciliationLine."Match Confidence"::Accepted, BankAccReconciliationLine."Match Confidence"::High); if BankAccReconciliationLine.FindSet() then begin repeat SetFilterToBankAccReconciliation(AppliedPaymentEntry, BankAccReconciliationLine); if FindTextMappings(BankAccReconciliationLine) then BankAccReconciliationLine.RejectAppliedPayment(); until BankAccReconciliationLine.Next() = 0; BankAccReconciliation.Get( BankAccReconciliationLine."Statement Type", BankAccReconciliationLine."Bank Account No.", BankAccReconciliationLine."Statement No."); CreateAppliedEntries(BankAccReconciliation); // Update match details for lines matched by text mapper BankAccReconciliationLine.SetRange( "Match Confidence", BankAccReconciliationLine."Match Confidence"::"High - Text-to-Account Mapping"); UpdatePaymentMatchDetails(BankAccReconciliationLine); end; end; /// <summary> /// Transfers unresolved amount differences to a specified general ledger account. /// Creates a new bank reconciliation line for the difference amount when the statement amount /// exceeds the applied amount, allowing users to account for fees, charges, or other adjustments. /// Splits the original line and applies the difference portion to the designated account. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line with amount difference to transfer.</param> /// <param name="TempGenJournalLine">Temporary journal line containing account and description details for the transfer.</param> procedure TransferDiffToAccount(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempGenJournalLine: Record "Gen. Journal Line" temporary) var BankAccReconciliation: Record "Bank Acc. Reconciliation"; TempBankPmtApplRule: Record "Bank Pmt. Appl. Rule" temporary; Score: Integer; Difference: Decimal; TransactionDate: Date; LineSplitMsg: Text; ParentLineNo: Integer; TransactionID: Text[50]; DifferenceTransferred: Boolean; SuppressMessage: Boolean; begin if BankAccReconciliationLine.IsEmpty() or (BankAccReconciliationLine.Difference = 0) then exit; TempGenJournalLine.Amount := BankAccReconciliationLine.Difference; TempGenJournalLine.Description := BankAccReconciliationLine.Description; if not TempGenJournalLine.Insert() then TempGenJournalLine.Modify(); RunTransferDifferencetoAccount(BankAccReconciliationLine, TempGenJournalLine, DifferenceTransferred); if DifferenceTransferred then begin if TempGenJournalLine."Account No." = '' then Error(MustChooseAccountErr); if BankAccReconciliationLine."Statement Amount" <> BankAccReconciliationLine.Difference then begin ParentLineNo := GetParentLineNo(BankAccReconciliationLine); Difference := BankAccReconciliationLine.Difference; LineSplitMsg := StrSubstNo(LineSplitTxt, Difference); TransactionDate := BankAccReconciliationLine."Transaction Date"; TransactionID := BankAccReconciliationLine."Transaction ID"; RevertAcceptedPmtToleranceFromAppliedEntries(BankAccReconciliationLine, Abs(Difference)); BankAccReconciliationLine."Statement Amount" := BankAccReconciliationLine."Applied Amount"; BankAccReconciliationLine.Difference := 0; BankAccReconciliationLine.Modify(); BankAccReconciliationLine.Init(); BankAccReconciliationLine."Statement Line No." := GetAvailableSplitLineNo(BankAccReconciliationLine, ParentLineNo); BankAccReconciliationLine."Parent Line No." := ParentLineNo; BankAccReconciliationLine.Description := TempGenJournalLine.Description; BankAccReconciliationLine."Transaction Text" := TempGenJournalLine.Description; BankAccReconciliationLine."Transaction Date" := TransactionDate; BankAccReconciliationLine."Statement Amount" := Difference; BankAccReconciliationLine."Transaction ID" := TransactionID; OnTransferDiffToAccountOnBeforeInsertBankAccReconciliationLine(BankAccReconciliationLine, TempGenJournalLine); BankAccReconciliationLine.Insert(); end; BankAccReconciliation.Get( BankAccReconciliationLine."Statement Type", BankAccReconciliationLine."Bank Account No.", BankAccReconciliationLine."Statement No."); Score := TempBankPmtApplRule.GetTextMapperScore(); TempBankStatementMatchingBuffer.AddMatchCandidate( BankAccReconciliationLine."Statement Line No.", -1, Score, TempGenJournalLine."Account Type", TempGenJournalLine."Account No."); CreateAppliedEntries(BankAccReconciliation); BankAccReconciliationLine.SetManualApplication(); BankAccReconciliationLine.SetRange("Statement Type", BankAccReconciliationLine."Statement Type"::"Payment Application"); BankAccReconciliationLine.SetRange("Bank Account No.", BankAccReconciliationLine."Bank Account No."); BankAccReconciliationLine.SetRange("Statement No.", BankAccReconciliationLine."Statement No."); BankAccReconciliationLine.SetRange("Statement Line No.", BankAccReconciliationLine."Statement Line No."); UpdatePaymentMatchDetails(BankAccReconciliationLine); if LineSplitMsg <> '' then begin OnBeforeShowLineSplitMessage(BankAccReconciliationLine, SuppressMessage); if not SuppressMessage then Message(LineSplitMsg); end; end; end; local procedure RunTransferDifferencetoAccount(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempGenJnlLine: Record "Gen. Journal Line" temporary; var DifferenceTransferred: Boolean) begin DifferenceTransferred := false; OnTransferDifference(BankAccReconciliationLine, TempGenJnlLine, DifferenceTransferred); if DifferenceTransferred then exit; if not GuiAllowed() then exit; DifferenceTransferred := Page.RunModal(Page::"Transfer Difference to Account", TempGenJnlLine) = Action::LookupOK; end; /// <summary> /// Performs matching analysis for a single bank reconciliation line against a specific customer ledger entry. /// Evaluates match criteria and calculates tolerance statistics to determine match quality and rule applicability. /// Returns the number of potential matching entries within and outside the configured amount tolerance. /// </summary> /// <param name="BankPmtApplRule">Returns the payment application rule used for matching evaluation.</param> /// <param name="BankAccReconciliationLine">Bank reconciliation line to match against customer entries.</param> /// <param name="AppliesToEntryNo">Specific customer ledger entry number to evaluate for matching.</param> /// <param name="NoOfLedgerEntriesWithinTolerance">Returns count of customer entries within amount tolerance.</param> /// <param name="NoOfLedgerEntriesOutsideTolerance">Returns count of customer entries outside amount tolerance.</param> procedure MatchSingleLineCustomer(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AppliesToEntryNo: Integer; var NoOfLedgerEntriesWithinTolerance: Integer; var NoOfLedgerEntriesOutsideTolerance: Integer) var MinAmount: Decimal; MaxAmount: Decimal; AccountNo: Code[20]; begin InitializeBankPmtApplSettings(); ApplyEntries := false; InitializeCustomerLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempCustomerLedgerEntryMatchingBuffer); InitializeDirectDebitCollectionEntriesMatchingBuffer(TempDirectDebitCollectionBuffer); if TempCustomerLedgerEntryMatchingBuffer.Get(AppliesToEntryNo, TempCustomerLedgerEntryMatchingBuffer."Account Type"::Customer) then; FindMatchingEntry( TempCustomerLedgerEntryMatchingBuffer, BankAccReconciliationLine, TempBankStatementMatchingBuffer."Account Type"::Customer, BankPmtApplRule); AccountNo := TempCustomerLedgerEntryMatchingBuffer."Account No."; BankAccReconciliationLine.GetAmountRangeForTolerance(MinAmount, MaxAmount); TempCustomerLedgerEntryMatchingBuffer.Reset(); TempCustomerLedgerEntryMatchingBuffer.SetRange("Account No.", AccountNo); NoOfLedgerEntriesWithinTolerance := TempCustomerLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", UsePaymentDiscounts); NoOfLedgerEntriesOutsideTolerance := TempCustomerLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesOutsideRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", UsePaymentDiscounts); end; /// <summary> /// Performs matching analysis for a single bank reconciliation line against a specific vendor ledger entry. /// Evaluates match criteria and calculates tolerance statistics to determine match quality and rule applicability. /// Returns the number of potential matching entries within and outside the configured amount tolerance. /// </summary> /// <param name="BankPmtApplRule">Returns the payment application rule used for matching evaluation.</param> /// <param name="BankAccReconciliationLine">Bank reconciliation line to match against vendor entries.</param> /// <param name="AppliesToEntryNo">Specific vendor ledger entry number to evaluate for matching.</param> /// <param name="NoOfLedgerEntriesWithinTolerance">Returns count of vendor entries within amount tolerance.</param> /// <param name="NoOfLedgerEntriesOutsideTolerance">Returns count of vendor entries outside amount tolerance.</param> procedure MatchSingleLineVendor(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AppliesToEntryNo: Integer; var NoOfLedgerEntriesWithinTolerance: Integer; var NoOfLedgerEntriesOutsideTolerance: Integer) var MinAmount: Decimal; MaxAmount: Decimal; AccountNo: Code[20]; begin InitializeBankPmtApplSettings(); ApplyEntries := false; InitializeVendorLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempVendorLedgerEntryMatchingBuffer); if not TempVendorLedgerEntryMatchingBuffer.Get(AppliesToEntryNo, TempVendorLedgerEntryMatchingBuffer."Account Type"::Vendor) then; FindMatchingEntry( TempVendorLedgerEntryMatchingBuffer, BankAccReconciliationLine, TempBankStatementMatchingBuffer."Account Type"::Vendor, BankPmtApplRule); AccountNo := TempVendorLedgerEntryMatchingBuffer."Account No."; BankAccReconciliationLine.GetAmountRangeForTolerance(MinAmount, MaxAmount); TempVendorLedgerEntryMatchingBuffer.Reset(); TempVendorLedgerEntryMatchingBuffer.SetRange("Account No.", AccountNo); NoOfLedgerEntriesWithinTolerance := TempVendorLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", UsePaymentDiscounts); NoOfLedgerEntriesOutsideTolerance := TempVendorLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesOutsideRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", UsePaymentDiscounts); end; /// <summary> /// Performs matching analysis for a single bank reconciliation line against a specific employee ledger entry. /// Evaluates match criteria and calculates tolerance statistics to determine match quality and rule applicability. /// Returns the number of potential matching entries within and outside the configured amount tolerance. /// </summary> /// <param name="BankPmtApplRule">Returns the payment application rule used for matching evaluation.</param> /// <param name="BankAccReconciliationLine">Bank reconciliation line to match against employee entries.</param> /// <param name="AppliesToEntryNo">Specific employee ledger entry number to evaluate for matching.</param> /// <param name="NoOfLedgerEntriesWithinTolerance">Returns count of employee entries within amount tolerance.</param> /// <param name="NoOfLedgerEntriesOutsideTolerance">Returns count of employee entries outside amount tolerance.</param> procedure MatchSingleLineEmployee(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AppliesToEntryNo: Integer; var NoOfLedgerEntriesWithinTolerance: Integer; var NoOfLedgerEntriesOutsideTolerance: Integer) var MinAmount: Decimal; MaxAmount: Decimal; AccountNo: Code[20]; begin InitializeBankPmtApplSettings(); ApplyEntries := false; InitializeEmployeeLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempEmployeeLedgerEntryMatchingBuffer); if not TempEmployeeLedgerEntryMatchingBuffer.Get(AppliesToEntryNo, TempEmployeeLedgerEntryMatchingBuffer."Account Type"::Employee) then; FindMatchingEntry( TempEmployeeLedgerEntryMatchingBuffer, BankAccReconciliationLine, TempBankStatementMatchingBuffer."Account Type"::Employee, BankPmtApplRule); AccountNo := TempEmployeeLedgerEntryMatchingBuffer."Account No."; BankAccReconciliationLine.GetAmountRangeForTolerance(MinAmount, MaxAmount); TempEmployeeLedgerEntryMatchingBuffer.Reset(); TempEmployeeLedgerEntryMatchingBuffer.SetRange("Account No.", AccountNo); NoOfLedgerEntriesWithinTolerance := TempEmployeeLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", UsePaymentDiscounts); NoOfLedgerEntriesOutsideTolerance := TempEmployeeLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesOutsideRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", UsePaymentDiscounts); end; /// <summary> /// Performs matching analysis for a single bank reconciliation line against a specific bank account ledger entry. /// Evaluates match criteria and calculates tolerance statistics to determine match quality and rule applicability. /// Returns the number of potential matching entries within and outside the configured amount tolerance. /// </summary> /// <param name="BankPmtApplRule">Returns the payment application rule used for matching evaluation.</param> /// <param name="BankAccReconciliationLine">Bank reconciliation line to match against bank account entries.</param> /// <param name="AppliesToEntryNo">Specific bank account ledger entry number to evaluate for matching.</param> /// <param name="NoOfLedgerEntriesWithinTolerance">Returns count of bank account entries within amount tolerance.</param> /// <param name="NoOfLedgerEntriesOutsideTolerance">Returns count of bank account entries outside amount tolerance.</param> procedure MatchSingleLineBankAccountLedgerEntry(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AppliesToEntryNo: Integer; var NoOfLedgerEntriesWithinTolerance: Integer; var NoOfLedgerEntriesOutsideTolerance: Integer) var MinAmount: Decimal; MaxAmount: Decimal; AccountNo: Code[20]; begin InitializeBankPmtApplSettings(); ApplyEntries := false; InitializeBankAccLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempBankAccLedgerEntryMatchingBuffer); if not TempBankAccLedgerEntryMatchingBuffer.Get(AppliesToEntryNo, TempBankAccLedgerEntryMatchingBuffer."Account Type"::"Bank Account") then; FindMatchingEntry( TempBankAccLedgerEntryMatchingBuffer, BankAccReconciliationLine, TempBankStatementMatchingBuffer."Account Type"::"Bank Account", BankPmtApplRule); AccountNo := TempBankAccLedgerEntryMatchingBuffer."Account No."; BankAccReconciliationLine.GetAmountRangeForTolerance(MinAmount, MaxAmount); TempBankAccLedgerEntryMatchingBuffer.Reset(); TempBankAccLedgerEntryMatchingBuffer.SetRange("Account No.", AccountNo); NoOfLedgerEntriesWithinTolerance := TempBankAccLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", false); NoOfLedgerEntriesOutsideTolerance := TempBankAccLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesOutsideRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", false); end; local procedure FindMatchingEntries(var TempBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line" temporary; var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; AccountType: Enum "Gen. Journal Account Type"; var SkipOtherEntries: Boolean) var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; begin InitializeBankPmtApplSettings(); TempLedgerEntryMatchingBuffer.Reset(); OnFindMatchingEntriesOnBeforeFindFirst(TempBankAccReconciliationLine, TempLedgerEntryMatchingBuffer, AccountType, SkipOtherEntries, ApplyEntries); if TempLedgerEntryMatchingBuffer.FindFirst() then repeat FindMatchingEntry(TempLedgerEntryMatchingBuffer, TempBankAccReconciliationLine, AccountType, BankPmtApplRule); if BankPmtApplSettings."Enable Apply Immediatelly" then if BankPmtApplRule."Apply Immediatelly" then begin SkipOtherEntries := true; exit; end; until TempLedgerEntryMatchingBuffer.Next() = 0; end; local procedure FindMatchingEntry(TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AccountType: Enum "Gen. Journal Account Type"; var BankPmtApplRule: Record "Bank Pmt. Appl. Rule") var Score: Integer; RemainingAmount: Decimal; begin if CanEntriesMatch( BankAccReconciliationLine, TempLedgerEntryMatchingBuffer."Remaining Amount", TempLedgerEntryMatchingBuffer."Posting Date") then begin MatchEntries(TempLedgerEntryMatchingBuffer, BankAccReconciliationLine, AccountType, BankPmtApplRule, RemainingAmount); Score := TempBankPmtApplRule.GetBestMatchScore(BankPmtApplRule); if Score >= MinimumMatchScore then TempBankStatementMatchingBuffer.AddMatchCandidate( BankAccReconciliationLine."Statement Line No.", TempLedgerEntryMatchingBuffer."Entry No.", Score, AccountType, TempLedgerEntryMatchingBuffer."Account No."); if BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" = BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::Yes then begin TempBankStatementMatchingBuffer.InsertOrUpdateOneToManyRule( TempLedgerEntryMatchingBuffer, BankAccReconciliationLine."Statement Line No.", BankPmtApplRule."Related Party Matched", AccountType, RemainingAmount); TempBankStmtMultipleMatchLine.InsertLine( TempLedgerEntryMatchingBuffer, BankAccReconciliationLine."Statement Line No.", AccountType); end; end; end; local procedure MatchEntries(TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AccountType: Enum "Gen. Journal Account Type"; var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; var RemainingAmount: Decimal) var IsHandled: Boolean; StartTime: DateTime; begin InitializeBankPmtApplSettings(); if AccountType = TempBankStatementMatchingBuffer."Account Type"::Customer then DirectDebitCollectionMatching(BankPmtApplRule, BankAccReconciliationLine, TempLedgerEntryMatchingBuffer); StartTime := CurrentDateTime(); RelatedPartyMatching(BankPmtApplRule, TempLedgerEntryMatchingBuffer, BankAccReconciliationLine, AccountType); TotalTimeRelatedPartyMatching += CurrentDateTime() - StartTime; IsHandled := false; OnFindMatchingEntryOnBeforeDocumentMatching(BankPmtApplRule, BankAccReconciliationLine, TempLedgerEntryMatchingBuffer, IsHandled, TempBankStatementMatchingBuffer, AccountType, TotalTimeDocumentNoMatching, TotalTimeDocumentNoMatchingForBankLedgerEntry, DocumentMatchedInfoText, LogInfoText); if not IsHandled then if AccountType <> TempBankStatementMatchingBuffer."Account Type"::"Bank Account" then begin StartTime := CurrentDateTime(); DocumentMatching( BankPmtApplRule, BankAccReconciliationLine, TempLedgerEntryMatchingBuffer."Document No.", TempLedgerEntryMatchingBuffer."External Document No.", TempLedgerEntryMatchingBuffer."Payment Reference"); TotalTimeDocumentNoMatching += CurrentDateTime() - StartTime; end else begin StartTime := CurrentDateTime(); DocumentMatchingForBankLedgerEntry(BankPmtApplRule, BankAccReconciliationLine, TempLedgerEntryMatchingBuffer); TotalTimeDocumentNoMatchingForBankLedgerEntry += CurrentDateTime() - StartTime; end; IsHandled := false; OnMatchEntriesOnAfterCalcTotalTimeDocumentNoMatching( BankPmtApplRule, BankAccReconciliationLine, TempLedgerEntryMatchingBuffer, AccountType, TempBankStatementMatchingBuffer, TotalTimeRelatedPartyMatching, TotalTimeAmountMatching, RemainingAmount, RelatedPartyMatchedInfoText, LogInfoText, TotalTimeStringNearness, UsePaymentDiscounts, TempOneToManyTempBankStatementMatchingBuffer, TempCustomerLedgerEntryMatchingBuffer, TempVendorLedgerEntryMatchingBuffer, TempEmployeeLedgerEntryMatchingBuffer, TempBankAccLedgerEntryMatchingBuffer, IsHandled, DocumentMatchedInfoText); if not IsHandled then begin StartTime := CurrentDateTime(); RemainingAmount := CalcRemainingAmount(TempLedgerEntryMatchingBuffer, BankAccReconciliationLine); AmountInclToleranceMatching( BankPmtApplRule, BankAccReconciliationLine, AccountType, RemainingAmount); TotalTimeAmountMatching += CurrentDateTime() - StartTime; end; end; local procedure CalcRemainingAmount(var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") RemainingAmount: Decimal var IsHandled: Boolean; begin IsHandled := false; OnBeforeCalcRemainingAmount(TempLedgerEntryMatchingBuffer, BankAccReconciliationLine, UsePaymentDiscounts, RemainingAmount, IsHandled); if IsHandled then exit(RemainingAmount); RemainingAmount := TempLedgerEntryMatchingBuffer.GetApplicableRemainingAmount(BankAccReconciliationLine, UsePaymentDiscounts); end; /// <summary> /// Initializes the customer ledger entries matching buffer with default apply entries setting. /// This overload calls the main initialization procedure with ApplyEntries set to false, /// populating the buffer for matching analysis without immediate application. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line context for filtering customer entries.</param> /// <param name="TempLedgerEntryMatchingBuffer">Temporary buffer to populate with customer ledger entry data.</param> procedure InitializeCustomerLedgerEntriesMatchingBuffer(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary) begin InitializeCustomerLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempLedgerEntryMatchingBuffer, false); end; /// <summary> /// Initializes the customer ledger entries matching buffer with open customer transactions. /// Populates a temporary buffer with customer ledger entries filtered by currency, document types, /// and application status. Configures the buffer for payment matching against bank reconciliation lines. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line context for filtering customer entries.</param> /// <param name="TempLedgerEntryMatchingBuffer">Temporary buffer to populate with customer ledger entry data.</param> /// <param name="ApplyEntries">True to filter out entries already applied in other journals; false to include all entries.</param> procedure InitializeCustomerLedgerEntriesMatchingBuffer(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; ApplyEntries: Boolean) var CustLedgerEntry: Record "Cust. Ledger Entry"; GeneralLedgerSetup: Record "General Ledger Setup"; SalesReceivablesSetup: Record "Sales & Receivables Setup"; CandidateFilterStartDate: Date; begin BankAccount.Get(BankAccReconciliationLine."Bank Account No."); SalesReceivablesSetup.Get(); CustLedgerEntry.SetRange(Open, true); CustLedgerEntry.SetFilter("Document Type", '%1|%2|%3|%4|%5', CustLedgerEntry."Document Type"::" ", CustLedgerEntry."Document Type"::Invoice, CustLedgerEntry."Document Type"::"Credit Memo", CustLedgerEntry."Document Type"::"Finance Charge Memo", CustLedgerEntry."Document Type"::Reminder); if ApplyEntries then CustLedgerEntry.SetRange("Applies-to ID", ''); CandidateFilterStartDate := GetCandidateFilterStartDate(BankAccReconciliationLine); if CandidateFilterStartDate <> 0D then CustLedgerEntry.SetFilter("Posting Date", '>=%1', CandidateFilterStartDate); OnInitCustomerLedgerEntriesMatchingBufferSetFilter(CustLedgerEntry, BankAccReconciliationLine); if BankAccount.IsInLocalCurrency() then begin CustLedgerEntry.SetAutoCalcFields("Remaining Amt. (LCY)"); if SalesReceivablesSetup."Appln. between Currencies" = SalesReceivablesSetup."Appln. between Currencies"::None then begin GeneralLedgerSetup.Get(); CustLedgerEntry.SetFilter("Currency Code", '=%1|=%2', '', GeneralLedgerSetup.GetCurrencyCode('')); end; end else begin CustLedgerEntry.SetAutoCalcFields("Remaining Amount"); CustLedgerEntry.SetRange("Currency Code", BankAccount."Currency Code"); end; OnInitCustomerLedgerEntriesMatchingBufferOnBeforeCustLedgerEntryFindSet(CustLedgerEntry); if CustLedgerEntry.FindSet() then repeat TempLedgerEntryMatchingBuffer.InsertFromCustomerLedgerEntry( CustLedgerEntry, BankAccount.IsInLocalCurrency(), UsePaymentDiscounts); until CustLedgerEntry.Next() = 0; end; /// <summary> /// Initializes the vendor ledger entries matching buffer with default apply entries setting. /// This overload calls the main initialization procedure with ApplyEntries set to false, /// populating the buffer for matching analysis without immediate application. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line context for filtering vendor entries.</param> /// <param name="TempLedgerEntryMatchingBuffer">Temporary buffer to populate with vendor ledger entry data.</param> procedure InitializeVendorLedgerEntriesMatchingBuffer(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary) begin InitializeVendorLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempLedgerEntryMatchingBuffer, false); end; /// <summary> /// Initializes the vendor ledger entries matching buffer with open vendor transactions. /// Populates a temporary buffer with vendor ledger entries filtered by currency, document types, /// and application status. Configures the buffer for payment matching against bank reconciliation lines. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line context for filtering vendor entries.</param> /// <param name="TempLedgerEntryMatchingBuffer">Temporary buffer to populate with vendor ledger entry data.</param> /// <param name="ApplyEntries">True to filter out entries already applied in other journals; false to include all entries.</param> procedure InitializeVendorLedgerEntriesMatchingBuffer(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; ApplyEntries: Boolean) var VendorLedgerEntry: Record "Vendor Ledger Entry"; GeneralLedgerSetup: Record "General Ledger Setup"; PurchasesPayablesSetup: Record "Purchases & Payables Setup"; CandidateFilterStartDate: Date; begin BankAccount.Get(BankAccReconciliationLine."Bank Account No."); PurchasesPayablesSetup.Get(); VendorLedgerEntry.SetRange(Open, true); VendorLedgerEntry.SetFilter("Document Type", '%1|%2|%3|%4|%5', VendorLedgerEntry."Document Type"::" ", VendorLedgerEntry."Document Type"::Invoice, VendorLedgerEntry."Document Type"::"Credit Memo", VendorLedgerEntry."Document Type"::"Finance Charge Memo", VendorLedgerEntry."Document Type"::Reminder); if ApplyEntries then VendorLedgerEntry.SetRange("Applies-to ID", ''); CandidateFilterStartDate := GetCandidateFilterStartDate(BankAccReconciliationLine); if CandidateFilterStartDate <> 0D then VendorLedgerEntry.SetFilter("Posting Date", '>=%1', CandidateFilterStartDate); OnInitVendorLedgerEntriesMatchingBufferSetFilter(VendorLedgerEntry, BankAccReconciliationLine); if BankAccount.IsInLocalCurrency() then begin VendorLedgerEntry.SetAutoCalcFields("Remaining Amt. (LCY)"); if PurchasesPayablesSetup."Appln. between Currencies" = PurchasesPayablesSetup."Appln. between Currencies"::None then begin GeneralLedgerSetup.Get(); VendorLedgerEntry.SetFilter("Currency Code", '=%1|=%2', '', GeneralLedgerSetup.GetCurrencyCode('')); end; end else begin VendorLedgerEntry.SetAutoCalcFields("Remaining Amount"); VendorLedgerEntry.SetRange("Currency Code", BankAccount."Currency Code"); end; OnInitVendorLedgerEntriesMatchingBufferOnAfterVendorLedgerEntryFindSet(VendorLedgerEntry); if VendorLedgerEntry.FindSet() then repeat TempLedgerEntryMatchingBuffer.InsertFromVendorLedgerEntry( VendorLedgerEntry, BankAccount.IsInLocalCurrency(), UsePaymentDiscounts); until VendorLedgerEntry.Next() = 0; end; /// <summary> /// Initializes the employee ledger entries matching buffer with default apply entries setting. /// This overload calls the main initialization procedure with ApplyEntries set to false, /// populating the buffer for matching analysis without immediate application. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line context for filtering employee entries.</param> /// <param name="TempLedgerEntryMatchingBuffer">Temporary buffer to populate with employee ledger entry data.</param> procedure InitializeEmployeeLedgerEntriesMatchingBuffer(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary) begin InitializeEmployeeLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempLedgerEntryMatchingBuffer, false); end; /// <summary> /// Initializes the employee ledger entries matching buffer with open employee transactions. /// Populates a temporary buffer with employee ledger entries filtered by currency, document types, /// and application status. Configures the buffer for payment matching against bank reconciliation lines. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line context for filtering employee entries.</param> /// <param name="TempLedgerEntryMatchingBuffer">Temporary buffer to populate with employee ledger entry data.</param> /// <param name="ApplyEntries">True to filter out entries already applied in other journals; false to include all entries.</param> procedure InitializeEmployeeLedgerEntriesMatchingBuffer(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; ApplyEntries: Boolean) var EmployeeLedgerEntry: Record "Employee Ledger Entry"; CandidateFilterStartDate: Date; begin BankAccount.Get(BankAccReconciliationLine."Bank Account No."); EmployeeLedgerEntry.SetRange(Open, true); EmployeeLedgerEntry.SetRange("Document Type", EmployeeLedgerEntry."Document Type"::" "); if ApplyEntries then EmployeeLedgerEntry.SetRange("Applies-to ID", ''); CandidateFilterStartDate := GetCandidateFilterStartDate(BankAccReconciliationLine); if CandidateFilterStartDate <> 0D then EmployeeLedgerEntry.SetFilter("Posting Date", '>=%1', CandidateFilterStartDate); OnInitEmployeeLedgerEntriesMatchingBufferSetFilter(EmployeeLedgerEntry, BankAccReconciliationLine); if not BankAccount.IsInLocalCurrency() then begin EmployeeLedgerEntry.SetAutoCalcFields("Remaining Amount"); EmployeeLedgerEntry.SetRange("Currency Code", BankAccount."Currency Code"); end else EmployeeLedgerEntry.SetAutoCalcFields("Remaining Amt. (LCY)"); OnInitEmployeeLedgerEntriesMatchingBufferOnAfterEmployeeLedgerEntryFindSet(EmployeeLedgerEntry); if EmployeeLedgerEntry.FindSet() then repeat TempLedgerEntryMatchingBuffer.InsertFromEmployeeLedgerEntry(EmployeeLedgerEntry, BankAccount.IsInLocalCurrency()); until EmployeeLedgerEntry.Next() = 0; end; /// <summary> /// Initializes the bank account ledger entries matching buffer with default skip reversed setting. /// This overload calls the main initialization procedure with SkipReversed set to false, /// populating the buffer for matching analysis including all bank entries. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line context for filtering bank account entries.</param> /// <param name="TempLedgerEntryMatchingBuffer">Temporary buffer to populate with bank account ledger entry data.</param> procedure InitializeBankAccLedgerEntriesMatchingBuffer(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary) begin InitializeBankAccLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempLedgerEntryMatchingBuffer, false); end; /// <summary> /// Initializes the bank account ledger entries matching buffer with open bank account transactions. /// Populates a temporary buffer with bank account ledger entries filtered by currency and reversal status. /// Configures the buffer for payment matching against bank reconciliation lines for internal transfers. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line context for filtering bank account entries.</param> /// <param name="TempLedgerEntryMatchingBuffer">Temporary buffer to populate with bank account ledger entry data.</param> /// <param name="SkipReversed">True to exclude reversed entries from matching consideration; false to include all entries.</param> procedure InitializeBankAccLedgerEntriesMatchingBuffer(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; SkipReversed: Boolean) var BankAccLedgerEntry: Record "Bank Account Ledger Entry"; GeneralLedgerSetup: Record "General Ledger Setup"; PurchasesPayablesSetup: Record "Purchases & Payables Setup"; CandidateFilterStartDate: Date; begin BankAccount.Get(BankAccReconciliationLine."Bank Account No."); PurchasesPayablesSetup.Get(); BankAccLedgerEntry.SetRange(Open, true); BankAccLedgerEntry.SetRange("Bank Account No.", BankAccReconciliationLine."Bank Account No."); if SkipReversed then BankAccLedgerEntry.SetRange(Reversed, false); CandidateFilterStartDate := GetCandidateFilterStartDate(BankAccReconciliationLine); if CandidateFilterStartDate <> 0D then BankAccLedgerEntry.SetFilter("Posting Date", '>=%1', CandidateFilterStartDate); OnInitBankAccLedgerEntriesMatchingBufferSetFilter(BankAccLedgerEntry, BankAccReconciliationLine); if BankAccount.IsInLocalCurrency() then if PurchasesPayablesSetup."Appln. between Currencies" = PurchasesPayablesSetup."Appln. between Currencies"::None then begin GeneralLedgerSetup.Get(); BankAccLedgerEntry.SetFilter("Currency Code", '=%1|=%2', '', GeneralLedgerSetup.GetCurrencyCode('')); end else BankAccLedgerEntry.SetRange("Currency Code", BankAccount."Currency Code"); if BankAccLedgerEntry.FindSet() then repeat TempLedgerEntryMatchingBuffer.InsertFromBankAccLedgerEntry(BankAccLedgerEntry); until BankAccLedgerEntry.Next() = 0; end; procedure InitializeDirectDebitCollectionEntriesMatchingBuffer(var TempDirectDebitCollectionEntryBuffer: Record "Direct Debit Collection Buffer" temporary) var DirectDebitCollectionEntry: Record "Direct Debit Collection Entry"; begin if DirectDebitCollectionEntry.FindSet() then repeat TempDirectDebitCollectionEntryBuffer.TransferFields(DirectDebitCollectionEntry); TempDirectDebitCollectionEntryBuffer.Insert(); until DirectDebitCollectionEntry.Next() = 0; end; /// <summary> /// Finds and returns text-to-account mapping rules applicable to a bank reconciliation line. /// Analyzes the transaction text against configured mapping patterns and populates a temporary /// table with matching rules that can be used for automatic account assignment. /// </summary> /// <param name="BankAccReconciliationLine">Bank reconciliation line to analyze for text mapping matches.</param> /// <param name="TempTextToAccMapping">Temporary table to populate with applicable mapping rules.</param> /// <returns>True if applicable text mapping rules were found; false otherwise.</returns> procedure FindApplicableTextMappings(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempTextToAccMapping: Record "Text-to-Account Mapping" temporary): Boolean begin exit(FindTextMappings(BankAccReconciliationLine, TempTextToAccMapping, true)); end; local procedure FindTextMappings(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"): Boolean var TempTextToAccMapping: Record "Text-to-Account Mapping" temporary; begin exit(FindTextMappings(BankAccReconciliationLine, TempTextToAccMapping, false)); end; local procedure SubstringMatchPercentage(ToMatchString: Text; OtherString: Text; var LongestCommonSubstringLength: Integer): Integer; var RecordMatchMgt: Codeunit "Record Match Mgt."; CommonSubstring: Text; MinLength: Integer; begin CommonSubstring := RecordMatchMgt.GetLongestCommonSubstring(ToMatchString, OtherString); LongestCommonSubstringLength := StrLen(CommonSubstring); MinLength := (StrLen(ToMatchString) + StrLen(OtherString) - Abs(StrLen(ToMatchString) - StrLen(OtherString))) / 2; if (MinLength = 0) or (LongestCommonSubstringLength < StrLen(ToMatchString)) then exit(0); exit(GetNormalizingFactor() * LongestCommonSubstringLength div MinLength); end; local procedure FindTextMappings(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempTextToAccMapping: Record "Text-to-Account Mapping" temporary; TrackApplicableRules: Boolean): Boolean var TextToAccMapping: Record "Text-to-Account Mapping"; BankAccLedgerEntry: Record "Bank Account Ledger Entry"; RecordMatchMgt: Codeunit "Record Match Mgt."; Nearness, LongestCommonSubstringLength : Integer; Score: Integer; AccountType: Enum "Gen. Journal Account Type"; AccountNo: Code[20]; EntryNo: Integer; TextMapperMatched: Boolean; begin TextMapperMatched := false; if TextToAccMapping.FindSet() then repeat Nearness := 0; OnFindTextMappingsOnBeforeCalculateStringNearness(BankAccReconciliationLine, TextToAccMapping, Nearness); if Nearness = 0 then Nearness := SubstringMatchPercentage(RecordMatchMgt.Trim(TextToAccMapping."Mapping Text"), BankAccReconciliationLine."Transaction Text", LongestCommonSubstringLength); case TextToAccMapping."Bal. Source Type" of TextToAccMapping."Bal. Source Type"::"G/L Account": if BankAccReconciliationLine."Statement Amount" >= 0 then AccountNo := TextToAccMapping."Debit Acc. No." else AccountNo := TextToAccMapping."Credit Acc. No."; else // Customer or Vendor AccountNo := TextToAccMapping."Bal. Source No."; end; if Nearness >= GetExactMatchTreshold() then begin Score := TempBankPmtApplRule.GetTextMapperScore(LongestCommonSubstringLength, LowerCase(BankAccReconciliationLine."Transaction Text").Contains(LowerCase(RecordMatchMgt.Trim(TextToAccMapping."Mapping Text")))); // Customers could post the expense via Journal. In this case there is a risk that we will create double entries. // We will seach for existing bank ledger entries with similar text in the similar range and mapp to that if FindBankAccLedgerEntry(BankAccLedgerEntry, BankAccReconciliationLine, TextToAccMapping, AccountNo) then begin EntryNo := BankAccLedgerEntry."Entry No."; AccountType := TempBankStatementMatchingBuffer."Account Type"::"Bank Account"; AccountNo := BankAccLedgerEntry."Bank Account No."; end else begin EntryNo := -TextToAccMapping."Line No."; // mark negative to identify text-mapper AccountType := Enum::"Gen. Journal Account Type".FromInteger(TextToAccMapping."Bal. Source Type"); end; TextMapperMatched := true; TempBankStatementMatchingBuffer.AddMatchCandidate( BankAccReconciliationLine."Statement Line No.", EntryNo, Score, AccountType, AccountNo); OnFindTextMappingsOnAfterTextMapperMatched(BankAccReconciliationLine, TextToAccMapping, TempBankStatementMatchingBuffer); if (TrackApplicableRules) then begin TempTextToAccMapping.TransferFields(TextToAccMapping, true); TempTextToAccMapping.Insert(); end; end; until TextToAccMapping.Next() = 0; exit(TextMapperMatched) end; local procedure FindBankAccLedgerEntry(var BankAccLedgerEntry: Record "Bank Account Ledger Entry"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; TextToAccountMapping: Record "Text-to-Account Mapping"; BalAccountNo: Code[20]): Boolean var RecordMatchMgt: Codeunit "Record Match Mgt."; Nearness: Integer; Found: Boolean; Handled: Boolean; begin OnFindBankAccLedgerEntryForTextToAccountMapping(Handled, Found, BankAccLedgerEntry, BankAccReconciliationLine, TextToAccountMapping, BalAccountNo); if Handled then exit(Found); BankAccLedgerEntry.SetRange("Bank Account No.", BankAccReconciliationLine."Bank Account No."); BankAccLedgerEntry.SetRange(Open, true); BankAccLedgerEntry.SetRange("Bal. Account Type", TextToAccountMapping."Bal. Source Type"); BankAccLedgerEntry.SetRange("Bal. Account No.", BalAccountNo); BankAccLedgerEntry.SetRange("Remaining Amount", BankAccReconciliationLine."Statement Amount"); if BankAccReconciliationLine."Transaction Date" = 0D then exit(false); BankAccLedgerEntry.SetFilter("Posting Date", '>=%1&<=%2', CalcDate('<-2D>', BankAccReconciliationLine."Transaction Date"), CalcDate('<+2D>', BankAccReconciliationLine."Transaction Date")); if not BankAccLedgerEntry.FindSet() then exit(false); repeat Nearness := RecordMatchMgt.CalculateStringNearness(RecordMatchMgt.Trim(TextToAccountMapping."Mapping Text"), BankAccLedgerEntry.Description, StrLen(BankAccLedgerEntry.Description), GetNormalizingFactor()); if Nearness >= GetExactMatchTreshold() then exit(true); until BankAccLedgerEntry.Next() = 0; exit(false); end; local procedure CreateAppliedEntries(BankAccReconciliation: Record "Bank Acc. Reconciliation") var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; begin TempBankStatementMatchingBuffer.Reset(); TempBankStatementMatchingBuffer.SetCurrentKey(Quality, "No. of Entries"); TempBankStatementMatchingBuffer.Ascending(false); TempBankStmtMultipleMatchLine.SetCurrentKey("Due Date"); OnCreateAppliedEntriesOnBeforeTempBankStatementMatchingBufferFindset(BankAccReconciliation, TempBankStatementMatchingBuffer, TempBankStmtMultipleMatchLine); if TempBankStatementMatchingBuffer.FindSet() then repeat BankAccReconciliationLine.Get( BankAccReconciliation."Statement Type", BankAccReconciliation."Bank Account No.", BankAccReconciliation."Statement No.", TempBankStatementMatchingBuffer."Line No."); if not StatementLineAlreadyApplied(TempBankStatementMatchingBuffer, BankAccReconciliationLine) then begin PrepareLedgerEntryForApplication(BankAccReconciliationLine); ApplyRecords(BankAccReconciliationLine, TempBankStatementMatchingBuffer); end; until TempBankStatementMatchingBuffer.Next() = 0; end; local procedure ApplyRecords(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary): Boolean var AppliedPaymentEntry: Record "Applied Payment Entry"; begin if TempBankStatementMatchingBuffer.Quality = 0 then exit(false); if TempBankStatementMatchingBuffer."One to Many Match" then ApplyOneToMany(BankAccReconciliationLine, TempBankStatementMatchingBuffer) else begin if EntryAlreadyApplied(TempBankStatementMatchingBuffer, BankAccReconciliationLine, TempBankStatementMatchingBuffer."Entry No.") then if not CanApplyManyToOne(TempBankStatementMatchingBuffer, BankAccReconciliationLine) then exit(false); AppliedPaymentEntry.ApplyFromBankStmtMatchingBuf(BankAccReconciliationLine, TempBankStatementMatchingBuffer, BankAccReconciliationLine."Statement Amount", TempBankStatementMatchingBuffer."Entry No."); end; Session.LogMessage('0000DKA', StrSubstNo(AppliedEntriesToBankStatementLineTxt, BankAccReconciliationLine.SystemId, TempBankStatementMatchingBuffer."Account Type", TempBankStatementMatchingBuffer."One to Many Match", TempBankStatementMatchingBuffer.Quality), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', PaymentRecPreformanceCategoryLbl); OnApplyRecordsOnAfterSendTraceTag(BankAccReconciliationLine, TempBankStatementMatchingBuffer); exit(true); end; local procedure ApplyOneToMany(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary) var PaymentMatchingDetails: Record "Payment Matching Details"; AppliedPaymentEntry: Record "Applied Payment Entry"; begin TempBankStmtMultipleMatchLine.SetRange("Line No.", TempBankStatementMatchingBuffer."Line No."); TempBankStmtMultipleMatchLine.SetRange("Account Type", TempBankStatementMatchingBuffer."Account Type"); TempBankStmtMultipleMatchLine.SetRange("Account No.", TempBankStatementMatchingBuffer."Account No."); TempBankStmtMultipleMatchLine.FindSet(); repeat AppliedPaymentEntry.TransferFromBankAccReconLine(BankAccReconciliationLine); if AppliedPaymentEntry.GetStmtLineRemAmtToApply() = 0 then PaymentMatchingDetails.CreatePaymentMatchingDetail(BankAccReconciliationLine, StrSubstNo(CannotApplyDocumentNoOneToManyApplicationTxt, TempBankStmtMultipleMatchLine."Document No.")) else begin Clear(AppliedPaymentEntry); if not EntryAlreadyApplied( TempBankStatementMatchingBuffer, BankAccReconciliationLine, TempBankStmtMultipleMatchLine."Entry No.") then AppliedPaymentEntry.ApplyFromBankStmtMatchingBuf(BankAccReconciliationLine, TempBankStatementMatchingBuffer, BankAccReconciliationLine."Statement Amount", TempBankStmtMultipleMatchLine."Entry No.") end; until TempBankStmtMultipleMatchLine.Next() = 0; end; local procedure CanEntriesMatch(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; Amount: Decimal; EntryPostingDate: Date) Result: Boolean var IsHandled: Boolean; begin IsHandled := false; OnBeforeCanEntriesMatch(BankAccReconciliationLine, Amount, EntryPostingDate, ApplyEntries, Result, IsHandled); if IsHandled then exit(Result); if not ApplyEntries then exit(true); if BankAccReconciliationLine."Statement Amount" * Amount < 0 then exit(false); if ApplyEntries then if BankAccReconciliationLine."Transaction Date" < EntryPostingDate then exit(false); exit(true); end; local procedure CanApplyManyToOne(TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; TempBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line" temporary): Boolean var AppliedPaymentEntry: Record "Applied Payment Entry"; HasPositiveApplications: Boolean; HasNegativeApplications: Boolean; begin // Many to one application is possbile if previous applied are for same Account SetFilterToRelatedApplications(AppliedPaymentEntry, TempBankStatementMatchingBuffer, TempBankAccReconciliationLine); if AppliedPaymentEntry.IsEmpty() then exit(false); // Not possible if positive and negative applications already exists AppliedPaymentEntry.SetFilter("Applied Amount", '>0'); HasPositiveApplications := not AppliedPaymentEntry.IsEmpty(); AppliedPaymentEntry.SetFilter("Applied Amount", '<0'); HasNegativeApplications := not AppliedPaymentEntry.IsEmpty(); if HasPositiveApplications and HasNegativeApplications then exit(false); // Remaining amount should not be 0 exit(GetRemainingAmount(TempBankStatementMatchingBuffer, TempBankAccReconciliationLine) <> 0); end; local procedure RelatedPartyMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AccountType: Enum "Gen. Journal Account Type") begin case AccountType of TempBankStatementMatchingBuffer."Account Type"::Customer: CustomerMatching(BankPmtApplRule, TempLedgerEntryMatchingBuffer."Account No.", BankAccReconciliationLine, AccountType); TempBankStatementMatchingBuffer."Account Type"::Vendor: VendorMatching(BankPmtApplRule, TempLedgerEntryMatchingBuffer."Account No.", BankAccReconciliationLine, AccountType); TempBankStatementMatchingBuffer."Account Type"::Employee: EmployeeMatching(BankPmtApplRule, TempLedgerEntryMatchingBuffer."Account No.", BankAccReconciliationLine, AccountType); TempBankStatementMatchingBuffer."Account Type"::"Bank Account": RelatedPartyMatchingForBankAccLedgEntry(BankPmtApplRule, TempLedgerEntryMatchingBuffer, BankAccReconciliationLine, AccountType); end; end; local procedure CustomerMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; AccountNo: Code[20]; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AccountType: Enum "Gen. Journal Account Type") var Customer: Record Customer; begin if IsCustomerBankAccountMatching( BankAccReconciliationLine."Related-Party Bank Acc. No.", AccountNo, BankAccReconciliationLine."Bank Account No.") then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::Fully; AppendText(RelatedPartyMatchedInfoText, MatchedRelatedPartyOnBankAccountMsg); exit; end; if not Customer.Get(AccountNo) then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::No; SendMissingRelatedPartyTelemetry(TempBankStatementMatchingBuffer."Account Type"::Customer); exit; end; RelatedPartyInfoMatching( BankPmtApplRule, BankAccReconciliationLine, Customer.Name, Customer.Address, Customer.City, AccountType); end; local procedure VendorMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; AccountNo: Code[20]; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AccountType: Enum "Gen. Journal Account Type") var Vendor: Record Vendor; begin if not Vendor.Get(AccountNo) then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::No; SendMissingRelatedPartyTelemetry(TempBankStatementMatchingBuffer."Account Type"::Vendor); exit; end; if IsVendorBankAccountMatching(BankAccReconciliationLine."Related-Party Bank Acc. No.", Vendor."No.", BankAccReconciliationLine."Bank Account No.") then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::Fully; AppendText(RelatedPartyMatchedInfoText, MatchedRelatedPartyOnBankAccountMsg); exit; end; RelatedPartyInfoMatching( BankPmtApplRule, BankAccReconciliationLine, Vendor.Name, Vendor.Address, Vendor.City, AccountType); end; local procedure EmployeeMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; AccountNo: Code[20]; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AccountType: Enum "Gen. Journal Account Type") var Employee: Record Employee; begin if not Employee.Get(AccountNo) then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::No; SendMissingRelatedPartyTelemetry(TempBankStatementMatchingBuffer."Account Type"::Employee); exit; end; if IsEmployeeBankAccountMatching(BankAccReconciliationLine."Related-Party Bank Acc. No.", Employee) then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::Fully; AppendText(RelatedPartyMatchedInfoText, MatchedRelatedPartyOnBankAccountMsg); exit; end; RelatedPartyInfoMatching( BankPmtApplRule, BankAccReconciliationLine, Employee.FullName(), Employee.Address, Employee.City, AccountType); end; local procedure RelatedPartyMatchingForBankAccLedgEntry(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AccountType: Enum "Gen. Journal Account Type") begin case TempLedgerEntryMatchingBuffer."Bal. Account Type" of TempLedgerEntryMatchingBuffer."Bal. Account Type"::Customer: CustomerMatching(BankPmtApplRule, TempLedgerEntryMatchingBuffer."Bal. Account No.", BankAccReconciliationLine, AccountType); TempLedgerEntryMatchingBuffer."Bal. Account Type"::Vendor: VendorMatching(BankPmtApplRule, TempLedgerEntryMatchingBuffer."Bal. Account No.", BankAccReconciliationLine, AccountType); TempLedgerEntryMatchingBuffer."Bal. Account Type"::"Bank Account", TempLedgerEntryMatchingBuffer."Bal. Account Type"::"G/L Account": BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::No; end; end; local procedure RelatedPartyInfoMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; Name: Text[100]; Address: Text[100]; City: Text[30]; AccountType: Enum "Gen. Journal Account Type") var Handled: Boolean; begin OnRelatedPartyInfoMatching(BankPmtApplRule, BankAccReconciliationLine, Name, Address, City, AccountType, RelatedPartyMatchedInfoText, Handled); if Handled then exit; InitializeBankPmtApplSettings(); BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::No; // If Strutured text present don't look at unstructured text if BankAccReconciliationLine."Related-Party Name" <> '' then begin // Use string nearness as names can be reversed, wrongly capitalized, etc IsNameMatching(BankAccReconciliationLine."Related-Party Name", Name, BankPmtApplRule, BankAccReconciliationLine); if BankPmtApplRule."Related Party Matched" = BankPmtApplRule."Related Party Matched"::Partially then begin // City and address should fully match if (BankAccReconciliationLine."Related-Party City" = City) and (BankAccReconciliationLine."Related-Party Address" = Address) and (City <> '') and (Address <> '') then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::Fully; AppendText(RelatedPartyMatchedInfoText, StrSubstNo(MatchedRelatedPartyOnBankStatementInfoMsg, StrSubstNo(RelatedPartyMatchInfoPlaceholderLbl, BankAccReconciliationLine.FieldName(BankAccReconciliationLine."Related-Party Name"), BankAccReconciliationLine.FieldName(BankAccReconciliationLine."Related-Party City"), BankAccReconciliationLine.FieldName(BankAccReconciliationLine."Related-Party Address")))); exit; end; if IsNameUnique(Name, AccountType) then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::Fully; AppendText(RelatedPartyMatchedInfoText, RelatedPartyNameIsUniqueMsg); exit; end; end; exit; end; // Unstructured text is using string nearness since user may shorten the name or mistype IsNameMatching(BankAccReconciliationLine."Transaction Text", Name, BankPmtApplRule, BankAccReconciliationLine); if BankPmtApplRule."Related Party Matched" = BankPmtApplRule."Related Party Matched"::Partially then if IsNameUnique(Name, AccountType) then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::Fully; AppendText(RelatedPartyMatchedInfoText, RelatedPartyNameIsUniqueMsg); exit; end; end; local procedure SendMissingRelatedPartyTelemetry(GenJournalAccountType: Enum "Gen. Journal Account Type") begin if MissingDataTypeTelemetrySent.Contains(GenJournalAccountType.AsInteger()) then exit; Session.LogMessage('0000FT3', StrSubstNo(MissingRelatedPartyTelemetryMsg, GenJournalAccountType), Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl); MissingDataTypeTelemetrySent.Add(GenJournalAccountType.AsInteger()); end; local procedure DocumentMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; DocNo: Code[20]; ExtDocNo: Code[35]; PaymentReference: Code[50]) var SearchText: Text; begin BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" := BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::No; if (PaymentReference <> '') and (BankAccReconciliationLine."Payment Reference No." = PaymentReference) then begin BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" := BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::Yes; AppendText(DocumentMatchedInfoText, DocumentNumberMatchedByPaymentReferenceMsg); exit; end; SearchText := UpperCase(BankAccReconciliationLine."Transaction Text" + ' ' + BankAccReconciliationLine."Additional Transaction Info"); if DocNoMatching(SearchText, DocNo) then begin BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" := BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::Yes; AppendText(DocumentMatchedInfoText, DocumentNumberMatchedInTransactionTextMsg); exit; end; if DocNoMatching(SearchText, ExtDocNo) then begin BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" := BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::Yes; AppendText(DocumentMatchedInfoText, ExternalDocumentNumberMatchedInTransactionTextMsg); end; end; procedure DocumentMatchingForBankLedgerEntry(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary) var SearchText: Text; ClosingEntriesDocumentNumbers: List of [Code[35]]; DisableMatch: Boolean; begin InitializeBankPmtApplSettings(); BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" := BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::No; SearchText := UpperCase(BankAccReconciliationLine."Transaction Text" + ' ' + BankAccReconciliationLine."Additional Transaction Info"); if DocNoMatching(SearchText, TempLedgerEntryMatchingBuffer."Document No.") then begin BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" := BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::Yes; exit; end; if DocNoMatching(SearchText, TempLedgerEntryMatchingBuffer."External Document No.") then begin BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" := BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::Yes; exit; end; OnDocumentMatchingForBankLedgerEntryOnBeforeMatch(SearchText, TempLedgerEntryMatchingBuffer, BankPmtApplRule); if BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" = BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::Yes then exit; if not BankPmtApplSettings."Bank Ledg Closing Doc No Match" then exit; OnDisableMatchBankLedgerEntriesFromClosingLedgerEntries(DisableMatch); if DisableMatch then exit; if not BankLedgerEntriesClosingDocumentNumbers.Get(TempLedgerEntryMatchingBuffer."Entry No.", ClosingEntriesDocumentNumbers) then PopulateClosingNumberDictionary(ClosingEntriesDocumentNumbers, TempLedgerEntryMatchingBuffer); if ClosingEntriesDocumentNumbers.Count() = 0 then exit; if ClosingDocumentMatching(SearchText, ClosingEntriesDocumentNumbers) then BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" := BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::Yes; end; local procedure PopulateClosingNumberDictionary(var ClosingEntriesDocumentNumbers: List of [Code[35]]; TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary) var CustLedgerEntry: Record "Cust. Ledger Entry"; CustLedgerEntry2: Record "Cust. Ledger Entry"; VendLedgerEntry: Record "Vendor Ledger Entry"; VendLedgerEntry2: Record "Vendor Ledger Entry"; StartTime: DateTime; begin StartTime := CurrentDateTime(); BankLedgerEntriesClosingDocumentNumbers.Add(TempLedgerEntryMatchingBuffer."Entry No.", ClosingEntriesDocumentNumbers); CustLedgerEntry.SetCurrentKey("Document No."); CustLedgerEntry.SetRange("Document No.", TempLedgerEntryMatchingBuffer."Document No."); CustLedgerEntry.SetRange("Document Type", TempLedgerEntryMatchingBuffer."Document Type"); CustLedgerEntry.SetRange("Posting Date", TempLedgerEntryMatchingBuffer."Posting Date"); if CustLedgerEntry.FindSet() then repeat CustLedgerEntry2.SetRange(Open, false); CustLedgerEntry2.SetRange("Closed by Entry No.", CustLedgerEntry."Entry No."); if CustLedgerEntry2.FindFirst() then ClosingEntriesDocumentNumbers.Add(CustLedgerEntry2."Document No."); until CustLedgerEntry.Next() = 0; VendLedgerEntry.SetCurrentKey("Document No."); VendLedgerEntry.SetRange("Document No.", TempLedgerEntryMatchingBuffer."Document No."); VendLedgerEntry.SetRange("Document Type", TempLedgerEntryMatchingBuffer."Document Type"); VendLedgerEntry.SetRange("Posting Date", TempLedgerEntryMatchingBuffer."Posting Date"); if VendLedgerEntry.FindSet() then repeat VendLedgerEntry2.SetRange(Open, false); VendLedgerEntry2.SetRange("Closed by Entry No.", VendLedgerEntry."Entry No."); if VendLedgerEntry2.FindFirst() then ClosingEntriesDocumentNumbers.Add(VendLedgerEntry2."Document No."); until VendLedgerEntry.Next() = 0; TotalTimeSearchingDocumentNoInLedgerEntries += CurrentDateTime() - StartTime; end; local procedure ClosingDocumentMatching(SearchText: Text; var ClosingDocumentNumbers: List of [Code[35]]): Boolean var I: Integer; begin TotalNoClosingDocumentMatches += 1; for I := 1 to ClosingDocumentNumbers.Count() do if (DocNoMatching(SearchText, ClosingDocumentNumbers.Get(I))) then begin HitCountClosingDocumentMatches += 1; exit(true); end; exit(false); end; procedure DocNoMatching(SearchText: Text; DocNo: Code[35]): Boolean var Position: Integer; begin if StrLen(DocNo) < GetMatchLengthTreshold() then exit(false); Position := StrPos(SearchText, DocNo); case Position of 0: exit(false); 1: begin if StrLen(SearchText) = StrLen(DocNo) then exit(true); exit(not IsAlphanumeric(SearchText[Position + StrLen(DocNo)])); end; else begin if StrLen(SearchText) < Position + StrLen(DocNo) then exit(not IsAlphanumeric(SearchText[Position - 1])); exit((not IsAlphanumeric(SearchText[Position - 1])) and (not IsAlphanumeric(SearchText[Position + StrLen(DocNo)]))); end; end; exit(true); end; local procedure AmountInclToleranceMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; AccountType: Enum "Gen. Journal Account Type"; RemainingAmount: Decimal) var NoOfEntries: Integer; MinAmount: Decimal; MaxAmount: Decimal; begin BankAccReconciliationLine.GetAmountRangeForTolerance(MinAmount, MaxAmount); BankPmtApplRule."Amount Incl. Tolerance Matched" := BankPmtApplRule."Amount Incl. Tolerance Matched"::"No Matches"; if (RemainingAmount < MinAmount) or (RemainingAmount > MaxAmount) then exit; NoOfEntries := 0; BankPmtApplRule."Amount Incl. Tolerance Matched" := BankPmtApplRule."Amount Incl. Tolerance Matched"::"Multiple Matches"; // Check for Multiple Hits for One To Many matches if BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" = BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::"Yes - Multiple" then begin TempOneToManyTempBankStatementMatchingBuffer.SetFilter("Total Remaining Amount", '>=%1&<=%2', MinAmount, MaxAmount); NoOfEntries += TempOneToManyTempBankStatementMatchingBuffer.Count(); if NoOfEntries > 1 then exit; end; // Check is a single match for One to One Matches case AccountType of TempBankStatementMatchingBuffer."Account Type"::Customer: NoOfEntries += TempCustomerLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", UsePaymentDiscounts); TempBankStatementMatchingBuffer."Account Type"::Vendor: NoOfEntries += TempVendorLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", UsePaymentDiscounts); TempBankStatementMatchingBuffer."Account Type"::Employee: NoOfEntries += TempEmployeeLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", UsePaymentDiscounts); TempBankStatementMatchingBuffer."Account Type"::"Bank Account": NoOfEntries += TempBankAccLedgerEntryMatchingBuffer.GetNoOfLedgerEntriesWithinRange( MinAmount, MaxAmount, BankAccReconciliationLine."Transaction Date", false); end; if NoOfEntries = 1 then BankPmtApplRule."Amount Incl. Tolerance Matched" := BankPmtApplRule."Amount Incl. Tolerance Matched"::"One Match" end; local procedure DirectDebitCollectionMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary) var DirectDebitCollection: Record "Direct Debit Collection"; StartTime: DateTime; begin StartTime := CurrentDateTime; BankPmtApplRule."Direct Debit Collect. Matched" := BankPmtApplRule."Direct Debit Collect. Matched"::"Not Considered"; if (BankAccReconciliationLine."Transaction ID" = '') or (StrLen(BankAccReconciliationLine."Transaction ID") > MaxStrLen(TempDirectDebitCollectionBuffer."Transaction ID")) then exit; TempDirectDebitCollectionBuffer.Reset(); TempDirectDebitCollectionBuffer.SetRange("Transaction ID", BankAccReconciliationLine."Transaction ID"); TempDirectDebitCollectionBuffer.SetFilter(Status, '%1|%2', TempDirectDebitCollectionBuffer.Status::"File Created", TempDirectDebitCollectionBuffer.Status::Posted); if TempDirectDebitCollectionBuffer.IsEmpty() then exit; BankPmtApplRule."Direct Debit Collect. Matched" := BankPmtApplRule."Direct Debit Collect. Matched"::No; TempDirectDebitCollectionBuffer.SetRange("Applies-to Entry No.", TempLedgerEntryMatchingBuffer."Entry No."); if TempDirectDebitCollectionBuffer.FindFirst() then if DirectDebitCollection.Get(TempDirectDebitCollectionBuffer."Direct Debit Collection No.") then if (DirectDebitCollection.Status in [DirectDebitCollection.Status::"File Created", DirectDebitCollection.Status::Posted, DirectDebitCollection.Status::Closed]) then BankPmtApplRule."Direct Debit Collect. Matched" := BankPmtApplRule."Direct Debit Collect. Matched"::Yes; TotalTimeDirectCollection += CurrentDateTime() - StartTime; end; local procedure IsNameMatching(Description: Text; CustVendValue: Text; var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"): Integer var STRNameNearness: Integer; begin InitializeBankPmtApplSettings(); case BankPmtApplSettings."RelatedParty Name Matching" of BankPmtApplSettings."RelatedParty Name Matching"::Disabled: begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::No; exit; end; BankPmtApplSettings."RelatedParty Name Matching"::"String Nearness": begin STRNameNearness := GetStringNearness(Description, CustVendValue); if STRNameNearness >= GetExactMatchTreshold() then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::Partially; if STRNameNearness < 100 then AppendText(RelatedPartyMatchedInfoText, StrSubstNo(TextPartialMatchMsg, BankAccReconciliationLine.FieldName("Related-Party Name"), STRNameNearness)); end; exit; end; BankPmtApplSettings."RelatedParty Name Matching"::"Exact Match with Permutations": begin IsNameMatchingWithPermutations(Description, CustVendValue, BankPmtApplRule); exit; end; end; end; local procedure IsNameMatchingWithPermutations(Description: Text; CustVendValue: Text; var BankPmtApplRule: Record "Bank Pmt. Appl. Rule") var SwappedFirstAndLastName: Text; FirstName: text; PositionOfFirstSpace: Integer; begin if StrLen(Description) < StrLen(CustVendValue) then exit; BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::No; if Description.Contains(CustVendValue) then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::Partially; exit; end; // To simplify the algorith for matching we will just put the first name to the end // This works optimal for First Name / Last Name and few other cultures PositionOfFirstSpace := CustVendValue.IndexOf(' '); if PositionOfFirstSpace <= 0 then exit; FirstName := CustVendValue.Substring(1, PositionOfFirstSpace - 1); SwappedFirstAndLastName += CustVendValue.Substring(PositionOfFirstSpace + 1, StrLen(CustVendValue) - PositionOfFirstSpace) + ' ' + FirstName; if Description.Contains(SwappedFirstAndLastName) then begin BankPmtApplRule."Related Party Matched" := BankPmtApplRule."Related Party Matched"::Partially; exit; end; end; local procedure GetStringNearness(Description: Text; CustVendValue: Text): Integer var RecordMatchMgt: Codeunit "Record Match Mgt."; StartTime: DateTime; Nearness: Integer; Disable: Boolean; begin if StrLen(Description) < (StrLen(CustVendValue) * GetCloseMatchTreshold() / GetNormalizingFactor()) then exit(0); Description := RecordMatchMgt.Trim(Description); OnDisableStringNearnessMatch(Disable); if Disable then exit(0); StartTime := CurrentDateTime(); Nearness := RecordMatchMgt.CalculateStringNearness(CustVendValue, Description, GetMatchLengthTreshold(), GetNormalizingFactor()); TotalTimeStringNearness += CurrentDateTime() - StartTime; exit(Nearness); end; local procedure IsCustomerBankAccountMatching(ValueFromBankStatement: Text; CustomerNo: Code[20]; BankAccountNo: Code[20]) Result: Boolean var CustomerBankAccount: Record "Customer Bank Account"; IsHandled: Boolean; begin IsHandled := false; OnBeforeIsCustomerBankAccountMatching(ValueFromBankStatement, CustomerNo, BankAccountNo, Result, IsHandled); if IsHandled then exit(Result); ValueFromBankStatement := BankAccountNoWithoutSpecialChars(ValueFromBankStatement); if ValueFromBankStatement = '' then exit(false); CustomerBankAccount.SetRange("Customer No.", CustomerNo); if CustomerBankAccount.FindSet() then repeat if BankAccountNoWithoutSpecialChars(CustomerBankAccount.GetBankAccountNo()) = ValueFromBankStatement then exit(true); until CustomerBankAccount.Next() = 0; exit(false); end; local procedure IsVendorBankAccountMatching(ValueFromBankStatement: Text; VendorNo: Code[20]; BankAccountNo: Code[20]) Result: Boolean var VendorBankAccount: Record "Vendor Bank Account"; IsHandled: Boolean; begin IsHandled := false; OnBeforeIsVendorBankAccountMatching(ValueFromBankStatement, VendorNo, BankAccountNo, Result, IsHandled); if IsHandled then exit(Result); ValueFromBankStatement := BankAccountNoWithoutSpecialChars(ValueFromBankStatement); if ValueFromBankStatement = '' then exit(false); VendorBankAccount.SetRange("Vendor No.", VendorNo); if VendorBankAccount.FindSet() then repeat if BankAccountNoWithoutSpecialChars(VendorBankAccount.GetBankAccountNo()) = ValueFromBankStatement then exit(true); until VendorBankAccount.Next() = 0; exit(false); end; local procedure IsEmployeeBankAccountMatching(ValueFromBankStatement: Text; Employee: Record Employee): Boolean begin ValueFromBankStatement := BankAccountNoWithoutSpecialChars(ValueFromBankStatement); if ValueFromBankStatement = '' then exit(false); if Employee."Bank Account No." <> '' then if BankAccountNoWithoutSpecialChars(Employee."Bank Account No.") = ValueFromBankStatement then exit(true); exit(false); end; local procedure BankAccountNoWithoutSpecialChars(Input: Text): Text begin exit(UpperCase(DelChr(Input, '=', DelChr(UpperCase(Input), '=', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')))); end; local procedure StatementLineAlreadyApplied(TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; TempBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line" temporary): Boolean var AppliedPaymentEntry: Record "Applied Payment Entry"; begin SetFilterToBankAccReconciliation(AppliedPaymentEntry, TempBankAccReconciliationLine); AppliedPaymentEntry.SetRange("Statement Line No.", TempBankStatementMatchingBuffer."Line No."); exit(not AppliedPaymentEntry.IsEmpty); end; local procedure EntryAlreadyApplied(TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; TempBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line" temporary; EntryNo: Integer): Boolean var AppliedPaymentEntry: Record "Applied Payment Entry"; begin SetFilterToBankAccReconciliation(AppliedPaymentEntry, TempBankAccReconciliationLine); AppliedPaymentEntry.SetRange("Account Type", TempBankStatementMatchingBuffer."Account Type"); AppliedPaymentEntry.SetRange("Applies-to Entry No.", EntryNo); exit(not AppliedPaymentEntry.IsEmpty); end; local procedure SetFilterToBankAccReconciliation(var AppliedPaymentEntry: Record "Applied Payment Entry"; TempBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line" temporary) begin AppliedPaymentEntry.FilterAppliedPmtEntry(TempBankAccReconciliationLine); AppliedPaymentEntry.SetRange("Statement Line No."); end; local procedure SetFilterToRelatedApplications(var AppliedPaymentEntry: Record "Applied Payment Entry"; TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; TempBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line" temporary) begin SetFilterToBankAccReconciliation(AppliedPaymentEntry, TempBankAccReconciliationLine); AppliedPaymentEntry.SetRange("Account Type", TempBankStatementMatchingBuffer."Account Type"); AppliedPaymentEntry.SetRange("Account No.", TempBankStatementMatchingBuffer."Account No."); AppliedPaymentEntry.SetRange("Applies-to Entry No.", TempBankStatementMatchingBuffer."Entry No."); end; local procedure GetRemainingAmount(TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; TempBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line" temporary): Decimal var TempAppliedPaymentEntry: Record "Applied Payment Entry" temporary; begin TempAppliedPaymentEntry.TransferFromBankAccReconLine(TempBankAccReconciliationLine); TempAppliedPaymentEntry."Account Type" := TempBankStatementMatchingBuffer."Account Type"; TempAppliedPaymentEntry."Account No." := TempBankStatementMatchingBuffer."Account No."; TempAppliedPaymentEntry."Applies-to Entry No." := TempBankStatementMatchingBuffer."Entry No."; exit(TempAppliedPaymentEntry.GetRemAmt() - TempAppliedPaymentEntry.GetAmtAppliedToOtherStmtLines()); end; local procedure ShowMatchSummary(BankAccReconciliation: Record "Bank Acc. Reconciliation") var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; MatchedCount: Integer; TotalCount: Integer; TextMatchCount: Integer; FinalText: Text; IsHandled: Boolean; begin BankAccReconciliationLine.SetRange("Statement Type", BankAccReconciliation."Statement Type"::"Payment Application"); BankAccReconciliationLine.SetRange("Bank Account No.", BankAccReconciliation."Bank Account No."); BankAccReconciliationLine.SetRange("Statement No.", BankAccReconciliation."Statement No."); TotalCount := BankAccReconciliationLine.Count(); BankAccReconciliationLine.SetFilter("Applied Entries", '>0'); MatchedCount := BankAccReconciliationLine.Count(); FinalText := StrSubstNo(MatchSummaryMsg, MatchedCount, TotalCount); IsHandled := false; OnShowMatchSummaryOnAfterSetFinalText(BankAccReconciliation, FinalText, IsHandled); if not IsHandled then Message(FinalText); BankAccReconciliationLine.SetRange("Match Confidence", BankAccReconciliationLine."Match Confidence"::"High - Text-to-Account Mapping"); TextMatchCount := BankAccReconciliationLine.Count(); Session.LogMessage('0000AIA', StrSubstNo(BankAccountRecTotalAndMatchedLinesLbl, TotalCount, MatchedCount, TextMatchCount), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', BankAccountRecCategoryLbl); end; local procedure UpdateOneToManyMatches(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin RemoveInvalidOneToManyMatches(); GetOneToManyMatches(); ScoreOneToManyMatches(BankAccReconciliationLine); end; local procedure ScoreOneToManyMatches(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; Score: Integer; begin if TempBankStatementMatchingBuffer.FindSet() then repeat BankPmtApplRule."Doc. No./Ext. Doc. No. Matched" := BankPmtApplRule."Doc. No./Ext. Doc. No. Matched"::"Yes - Multiple"; BankPmtApplRule."Related Party Matched" := TempBankStatementMatchingBuffer."Related Party Matched"; BankAccReconciliationLine.Get( BankAccReconciliationLine."Statement Type", BankAccReconciliationLine."Bank Account No.", BankAccReconciliationLine."Statement No.", TempBankStatementMatchingBuffer."Line No."); AmountInclToleranceMatching( BankPmtApplRule, BankAccReconciliationLine, TempBankStatementMatchingBuffer."Account Type", TempBankStatementMatchingBuffer."Total Remaining Amount"); Score := TempBankPmtApplRule.GetBestMatchScore(BankPmtApplRule); TempBankStatementMatchingBuffer.Quality := Score; TempBankStatementMatchingBuffer.Modify(); until TempBankStatementMatchingBuffer.Next() = 0; TempBankStatementMatchingBuffer.Reset(); end; local procedure RemoveInvalidOneToManyMatches() begin TempBankStatementMatchingBuffer.Reset(); TempBankStatementMatchingBuffer.SetRange("One to Many Match", true); TempBankStatementMatchingBuffer.SetFilter("No. of Entries", '=1'); TempBankStatementMatchingBuffer.DeleteAll(true); TempBankStatementMatchingBuffer.Reset(); end; local procedure GetOneToManyMatches() begin TempBankStatementMatchingBuffer.Reset(); TempBankStatementMatchingBuffer.SetRange("One to Many Match", true); TempBankStatementMatchingBuffer.SetFilter("No. of Entries", '>1'); if TempBankStatementMatchingBuffer.FindSet() then repeat TempOneToManyTempBankStatementMatchingBuffer := TempBankStatementMatchingBuffer; TempOneToManyTempBankStatementMatchingBuffer.Insert(true); until TempBankStatementMatchingBuffer.Next() = 0; end; procedure GetExactMatchTreshold(): Decimal begin exit(0.95 * GetNormalizingFactor()); end; procedure GetCloseMatchTreshold(): Decimal begin exit(0.65 * GetNormalizingFactor()); end; local procedure GetMatchLengthTreshold(): Decimal begin exit(4); end; procedure GetNormalizingFactor(): Decimal begin exit(100); end; local procedure GetLowestMatchScore(): Integer var Score: Integer; begin if not ApplyEntries then exit(0); TempBankPmtApplRule.SetFilter("Match Confidence", '<>%1', TempBankPmtApplRule."Match Confidence"::None); TempBankPmtApplRule.SetCurrentKey(Score); TempBankPmtApplRule.Ascending(false); Score := 0; if TempBankPmtApplRule.FindLast() then Score := TempBankPmtApplRule.Score; TempBankPmtApplRule.Reset(); exit(Score); end; local procedure IsNameUnique(Name: Text[100]; AccountType: Enum "Gen. Journal Account Type"): Boolean var Customer: Record Customer; Vendor: Record Vendor; begin case AccountType of TempBankStatementMatchingBuffer."Account Type"::Customer: begin Customer.SetFilter(Name, '%1', '@*' + Name + '*'); exit(Customer.Count = 1); end; TempBankStatementMatchingBuffer."Account Type"::Vendor: begin Vendor.SetFilter(Name, '%1', '@*' + Name + '*'); exit(Vendor.Count = 1); end; end; end; local procedure IsAlphanumeric(Character: Char): Boolean begin exit((Character in ['0' .. '9']) or (Character in ['A' .. 'Z']) or (Character in ['a' .. 'z'])); end; procedure GetBankStatementMatchingBuffer(var TempBankStatementMatchingBuffer2: Record "Bank Statement Matching Buffer" temporary) begin TempBankStatementMatchingBuffer2.Copy(TempBankStatementMatchingBuffer, true); TempBankStatementMatchingBuffer2.Reset(); end; procedure GetLedgerEntriesAsMatchingBuffer(var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var BankPmtApplSettings: Record "Bank Pmt. Appl. Settings"; begin BankPmtApplSettings.GetOrInsert(); if not BankPmtApplSettings."Cust Ledg Hidden In Apply Man" then GetCustomerLedgerEntriesAsMatchingBuffer(TempBankStatementMatchingBuffer, BankAccReconciliationLine); if not BankPmtApplSettings."Vend Ledg Hidden In Apply Man" then GetVendorLedgerEntriesAsMatchingBuffer(TempBankStatementMatchingBuffer, BankAccReconciliationLine); if not BankPmtApplSettings."Empl Ledg Hidden In Apply Man" then GetEmployeeLedgerEntriesAsMatchingBuffer(TempBankStatementMatchingBuffer, BankAccReconciliationLine); if not BankPmtApplSettings."Bank Ledg Hidden In Apply Man" then GetBankLedgerEntriesAsMatchingBuffer(TempBankStatementMatchingBuffer, BankAccReconciliationLine); end; procedure GetCustomerLedgerEntriesAsMatchingBuffer(var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var GenJournalAccountType: Enum "Gen. Journal Account Type"; begin InitializeCustomerLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempCustomerLedgerEntryMatchingBuffer); TempCustomerLedgerEntryMatchingBuffer.Reset(); if TempCustomerLedgerEntryMatchingBuffer.FindSet() then repeat TempBankStatementMatchingBuffer.AddMatchCandidate( BankAccReconciliationLine."Statement Line No.", TempCustomerLedgerEntryMatchingBuffer."Entry No.", 0, GenJournalAccountType::Customer, TempCustomerLedgerEntryMatchingBuffer."Account No."); until TempCustomerLedgerEntryMatchingBuffer.Next() = 0; end; procedure GetVendorLedgerEntriesAsMatchingBuffer(var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var GenJournalAccountType: Enum "Gen. Journal Account Type"; begin InitializeVendorLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempVendorLedgerEntryMatchingBuffer); TempVendorLedgerEntryMatchingBuffer.Reset(); if TempVendorLedgerEntryMatchingBuffer.FindSet() then repeat TempBankStatementMatchingBuffer.AddMatchCandidate( BankAccReconciliationLine."Statement Line No.", TempVendorLedgerEntryMatchingBuffer."Entry No.", 0, GenJournalAccountType::Vendor, TempVendorLedgerEntryMatchingBuffer."Account No."); until TempVendorLedgerEntryMatchingBuffer.Next() = 0; end; procedure GetEmployeeLedgerEntriesAsMatchingBuffer(var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var GenJournalAccountType: Enum "Gen. Journal Account Type"; begin InitializeEmployeeLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempEmployeeLedgerEntryMatchingBuffer); TempEmployeeLedgerEntryMatchingBuffer.Reset(); if TempEmployeeLedgerEntryMatchingBuffer.FindSet() then repeat TempBankStatementMatchingBuffer.AddMatchCandidate( BankAccReconciliationLine."Statement Line No.", TempEmployeeLedgerEntryMatchingBuffer."Entry No.", 0, GenJournalAccountType::Employee, TempEmployeeLedgerEntryMatchingBuffer."Account No."); until TempEmployeeLedgerEntryMatchingBuffer.Next() = 0; end; procedure GetBankLedgerEntriesAsMatchingBuffer(var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var GenJournalAccountType: Enum "Gen. Journal Account Type"; begin InitializeBankAccLedgerEntriesMatchingBuffer(BankAccReconciliationLine, TempBankAccLedgerEntryMatchingBuffer); TempBankAccLedgerEntryMatchingBuffer.Reset(); if TempBankAccLedgerEntryMatchingBuffer.FindSet() then repeat TempBankStatementMatchingBuffer.AddMatchCandidate( BankAccReconciliationLine."Statement Line No.", TempBankAccLedgerEntryMatchingBuffer."Entry No.", 0, GenJournalAccountType::"Bank Account", TempBankAccLedgerEntryMatchingBuffer."Account No."); until TempBankAccLedgerEntryMatchingBuffer.Next() = 0; end; local procedure UpdatePaymentMatchDetails(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var BankAccReconciliationLine2: Record "Bank Acc. Reconciliation Line"; begin BankAccReconciliationLine2.CopyFilters(BankAccReconciliationLine); OnUpdatePaymentMatchDetailsOnAfterBankAccReconciliationLine2SetFilters(BankAccReconciliationLine2, BankAccReconciliationLine); if BankAccReconciliationLine2.FindSet() then repeat BankAccReconciliationLine2.CalcFields("Match Confidence", "Match Quality"); AddWarningsForTextMapperOverriden(BankAccReconciliationLine2); AddWarningsForStatementCanBeAppliedToMultipleEntries(BankAccReconciliationLine2); AddWarningsForMultipleStatementLinesCouldBeAppliedToEntry(BankAccReconciliationLine2); until BankAccReconciliationLine2.Next() = 0; end; local procedure DeletePaymentMatchDetails(BankAccReconciliation: Record "Bank Acc. Reconciliation") var PaymentMatchingDetails: Record "Payment Matching Details"; begin PaymentMatchingDetails.SetRange("Statement Type", BankAccReconciliation."Statement Type"); PaymentMatchingDetails.SetRange("Bank Account No.", BankAccReconciliation."Bank Account No."); PaymentMatchingDetails.SetRange("Statement No.", BankAccReconciliation."Statement No."); OnDeletePaymentMatchDetailsOnAfterPaymentMatchingDetailsSetFilters(PaymentMatchingDetails, BankAccReconciliation); PaymentMatchingDetails.DeleteAll(true); end; local procedure DeleteAppliedPaymentEntries(BankAccReconciliation: Record "Bank Acc. Reconciliation"; Overwrite: Boolean) var AppliedPaymentEntry: Record "Applied Payment Entry"; begin AppliedPaymentEntry.SetRange("Statement Type", BankAccReconciliation."Statement Type"); AppliedPaymentEntry.SetRange("Bank Account No.", BankAccReconciliation."Bank Account No."); AppliedPaymentEntry.SetRange("Statement No.", BankAccReconciliation."Statement No."); if not Overwrite then AppliedPaymentEntry.SetFilter("Match Confidence", '<>%1&<>%2', AppliedPaymentEntry."Match Confidence"::Accepted, AppliedPaymentEntry."Match Confidence"::Manual); OnDeleteAppliedPaymentEntriesOnAfterAppliedPaymentEntrySetFilters(AppliedPaymentEntry, BankAccReconciliation); AppliedPaymentEntry.DeleteAll(true); end; local procedure AddWarningsForTextMapperOverriden(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var PaymentMatchingDetails: Record "Payment Matching Details"; BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; begin if BankAccReconciliationLine."Match Quality" <= BankPmtApplRule.GetTextMapperScore() then exit; TempBankStatementMatchingBuffer.Reset(); TempBankStatementMatchingBuffer.SetRange("Line No.", BankAccReconciliationLine."Statement Line No."); TempBankStatementMatchingBuffer.SetRange(Quality, BankPmtApplRule.GetTextMapperScore()); if TempBankStatementMatchingBuffer.Count > 0 then PaymentMatchingDetails.CreatePaymentMatchingDetail(BankAccReconciliationLine, StrSubstNo(TextMapperRulesOverridenTxt, TempBankStatementMatchingBuffer.Count, BankAccReconciliationLine."Match Confidence")); end; local procedure AddWarningsForStatementCanBeAppliedToMultipleEntries(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var PaymentMatchingDetails: Record "Payment Matching Details"; BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; MinRangeValue: Integer; MaxRangeValue: Integer; begin if BankAccReconciliationLine."Match Confidence" = BankAccReconciliationLine."Match Confidence"::None then exit; if BankAccReconciliationLine."Match Quality" = BankPmtApplRule.GetTextMapperScore() then exit; TempBankStatementMatchingBuffer.Reset(); TempBankStatementMatchingBuffer.SetRange("Line No.", BankAccReconciliationLine."Statement Line No."); MinRangeValue := BankPmtApplRule.GetLowestScoreInRange(BankAccReconciliationLine."Match Quality"); MaxRangeValue := BankPmtApplRule.GetHighestScoreInRange(BankAccReconciliationLine."Match Quality"); TempBankStatementMatchingBuffer.SetRange(Quality, MinRangeValue, MaxRangeValue); if TempBankStatementMatchingBuffer.Count > 1 then PaymentMatchingDetails.CreatePaymentMatchingDetail(BankAccReconciliationLine, StrSubstNo(MultipleEntriesWithSilarConfidenceFoundTxt, TempBankStatementMatchingBuffer.Count)); end; local procedure AddWarningsForMultipleStatementLinesCouldBeAppliedToEntry(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") var PaymentMatchingDetails: Record "Payment Matching Details"; BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; EntryNo: Integer; MinRangeValue: Integer; MaxRangeValue: Integer; begin if BankAccReconciliationLine."Match Confidence" = BankAccReconciliationLine."Match Confidence"::None then exit; if BankAccReconciliationLine."Match Quality" = BankPmtApplRule.GetTextMapperScore() then exit; TempBankStatementMatchingBuffer.Reset(); // Get Entry No. TempBankStatementMatchingBuffer.SetRange("Line No.", BankAccReconciliationLine."Statement Line No."); TempBankStatementMatchingBuffer.SetRange(Quality, BankAccReconciliationLine."Match Quality"); TempBankStatementMatchingBuffer.FindFirst(); EntryNo := TempBankStatementMatchingBuffer."Entry No."; MinRangeValue := BankPmtApplRule.GetLowestScoreInRange(BankAccReconciliationLine."Match Quality"); MaxRangeValue := BankPmtApplRule.GetHighestScoreInRange(BankAccReconciliationLine."Match Quality"); TempBankStatementMatchingBuffer.Reset(); TempBankStatementMatchingBuffer.SetRange("Entry No.", EntryNo); TempBankStatementMatchingBuffer.SetRange(Quality, MinRangeValue, MaxRangeValue); TempBankStatementMatchingBuffer.SetFilter("Line No.", '<>%1', BankAccReconciliationLine."Statement Line No."); if TempBankStatementMatchingBuffer.Count > 1 then PaymentMatchingDetails.CreatePaymentMatchingDetail(BankAccReconciliationLine, StrSubstNo(MultipleStatementLinesWithSameConfidenceFoundTxt, TempBankStatementMatchingBuffer.Count)); end; local procedure AppendText(var MainText: Text; TextToAppend: Text) begin if not LogInfoText then exit; if (MainText <> '') then MainText += GetNewLineText() + GetNewLineText(); MainText += TextToAppend; end; procedure SetApplyEntries(NewApplyEntries: Boolean) begin ApplyEntries := NewApplyEntries; end; local procedure GetAvailableSplitLineNo(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; ParentLineNo: Integer): Integer var SplitLineNo: Integer; begin SplitLineNo := BankAccReconciliationLine."Statement Line No." + 1; BankAccReconciliationLine.SetRange("Parent Line No.", ParentLineNo); if BankAccReconciliationLine.FindLast() then SplitLineNo := BankAccReconciliationLine."Statement Line No." + 1; exit(SplitLineNo) end; local procedure GetParentLineNo(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"): Integer begin if BankAccReconciliationLine."Parent Line No." <> 0 then exit(BankAccReconciliationLine."Parent Line No."); exit(BankAccReconciliationLine."Statement Line No."); end; local procedure PrepareLedgerEntryForApplication(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin if TempBankStatementMatchingBuffer."Entry No." <= 0 then // text mapping has "Entry No." = -10000 exit; SetApplicationDataInCVLedgEntry( TempBankStatementMatchingBuffer."Account Type", TempBankStatementMatchingBuffer."Entry No.", BankAccReconciliationLine.GetAppliesToID()); end; procedure SetApplicationDataInCVLedgEntry(AccountType: Enum "Gen. Journal Account Type"; EntryNo: Integer; AppliesToID: Code[50]) var BankAccReconLine: Record "Bank Acc. Reconciliation Line"; begin if EntryNo = 0 then exit; case AccountType of BankAccReconLine."Account Type"::Customer: SetCustAppicationData(EntryNo, AppliesToID); BankAccReconLine."Account Type"::Vendor: SetVendAppicationData(EntryNo, AppliesToID); BankAccReconLine."Account Type"::Employee: SetEmployeeAppicationData(EntryNo, AppliesToID); end; end; local procedure SetCustAppicationData(EntryNo: Integer; AppliesToID: Code[50]) var CustLedgEntry: Record "Cust. Ledger Entry"; begin CustLedgEntry.Get(EntryNo); CustLedgEntry.CalcFields("Remaining Amount"); CustLedgEntry."Applies-to ID" := AppliesToID; CustLedgEntry."Amount to Apply" := CustLedgEntry."Remaining Amount"; OnSetCustAppicationDataOnBeforeCustEntryEdit(CustLedgEntry); CODEUNIT.Run(CODEUNIT::"Cust. Entry-Edit", CustLedgEntry); end; local procedure SetVendAppicationData(EntryNo: Integer; AppliesToID: Code[50]) var VendLedgEntry: Record "Vendor Ledger Entry"; begin VendLedgEntry.Get(EntryNo); VendLedgEntry.CalcFields("Remaining Amount"); VendLedgEntry."Applies-to ID" := AppliesToID; VendLedgEntry."Amount to Apply" := VendLedgEntry."Remaining Amount"; OnSetVendAppicationDataOnBeforeVendEntryEdit(VendLedgEntry); CODEUNIT.Run(CODEUNIT::"Vend. Entry-Edit", VendLedgEntry); end; local procedure SetEmployeeAppicationData(EntryNo: Integer; AppliesToID: Code[50]) var EmployeeLedgEntry: Record "Employee Ledger Entry"; begin EmployeeLedgEntry.Get(EntryNo); EmployeeLedgEntry.CalcFields("Remaining Amount"); EmployeeLedgEntry."Applies-to ID" := AppliesToID; EmployeeLedgEntry."Amount to Apply" := EmployeeLedgEntry."Remaining Amount"; CODEUNIT.Run(CODEUNIT::"Empl. Entry-Edit", EmployeeLedgEntry); end; local procedure GetNewLineText(): Text var NewLine: array[2] of Char; begin NewLine[1] := 10; NewLine[2] := 13; exit(StrSubstNo(NewLinePlaceHolderLbl, NewLine[1], NewLine[2])); end; local procedure RevertAcceptedPmtToleranceFromAppliedEntries(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; Difference: Decimal) var AppliedPmtEntry: Record "Applied Payment Entry"; CustLedgerEntry: Record "Cust. Ledger Entry"; VendorLedgerEntry: Record "Vendor Ledger Entry"; begin if Difference = 0 then exit; AppliedPmtEntry.FilterAppliedPmtEntry(BankAccReconciliationLine); AppliedPmtEntry.SetFilter("Applies-to Entry No.", '<>%1', 0); if not AppliedPmtEntry.FindSet() then exit; repeat case AppliedPmtEntry."Account Type" of AppliedPmtEntry."Account Type"::Customer: begin CustLedgerEntry.Get(AppliedPmtEntry."Applies-to Entry No."); if CustLedgerEntry."Accepted Payment Tolerance" <> 0 then begin if -CustLedgerEntry."Accepted Payment Tolerance" > Difference then begin CustLedgerEntry."Accepted Payment Tolerance" += Difference; Difference := 0; end else begin Difference += CustLedgerEntry."Accepted Payment Tolerance"; CustLedgerEntry."Accepted Payment Tolerance" := 0; end; CustLedgerEntry.Modify(); end; end; AppliedPmtEntry."Account Type"::Vendor: begin VendorLedgerEntry.Get(AppliedPmtEntry."Applies-to Entry No."); if VendorLedgerEntry."Accepted Payment Tolerance" <> 0 then begin if VendorLedgerEntry."Accepted Payment Tolerance" > Difference then begin VendorLedgerEntry."Accepted Payment Tolerance" -= Difference; Difference := 0; end else begin Difference -= VendorLedgerEntry."Accepted Payment Tolerance"; VendorLedgerEntry."Accepted Payment Tolerance" := 0; end; VendorLedgerEntry.Modify(); end; end; end; until (AppliedPmtEntry.Next() = 0) or (Difference = 0); end; local procedure InitializeBankPmtApplSettings() begin if BankPmtApplSettingsInitialized then exit; BankPmtApplSettings.GetOrInsert(); BankPmtApplSettingsInitialized := true; end; local procedure GetCandidateFilterStartDate(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"): Date var ReferenceDate: Date; begin InitializeBankPmtApplSettings(); // Buffers are built once per journal, so the batch's earliest transaction date is used to keep every line's candidates. if CandidateFilterReferenceDate <> 0D then ReferenceDate := CandidateFilterReferenceDate else ReferenceDate := BankAccReconciliationLine."Transaction Date"; exit(BankPmtApplSettings.GetCandidateLookbackStartDate(ReferenceDate)); end; /// <summary> /// Event raised after executing the main bank payment matching code. /// </summary> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> [IntegrationEvent(false, false)] local procedure OnAfterCode(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin end; /// <summary> /// Event raised before calculating the remaining amount for payment matching. /// </summary> /// <param name="TempLedgerEntryMatchingBuffer">The temporary ledger entry matching buffer record.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="UsePaymentDiscounts">Indicates whether to use payment discounts in calculation.</param> /// <param name="RemainingAmount">The calculated remaining amount.</param> /// <param name="IsHandled">Indicates whether the event has been handled.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCalcRemainingAmount(var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; UsePaymentDiscounts: Boolean; var RemainingAmount: Decimal; var IsHandled: Boolean) begin end; /// <summary> /// Event raised before checking if customer bank account is matching. /// </summary> /// <param name="ValueFromBankStatement">The value from the bank statement.</param> /// <param name="CustomerNo">The customer number.</param> /// <param name="BankAccountNo">The bank account number.</param> /// <param name="Result">The matching result.</param> /// <param name="IsHandled">Indicates whether the event has been handled.</param> [IntegrationEvent(false, false)] local procedure OnBeforeIsCustomerBankAccountMatching(ValueFromBankStatement: Text; CustomerNo: Code[20]; BankAccountNo: Code[20]; var Result: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Event raised before notifying if entries are matched elsewhere. /// </summary> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="IsHandled">Indicates whether the event has been handled.</param> [IntegrationEvent(true, false)] local procedure OnBeforeNotifyIfEntriesMatchedElsewhere(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var IsHandled: Boolean) begin end; /// <summary> /// Event raised before checking if vendor bank account is matching. /// </summary> /// <param name="ValueFromBankStatement">The value from the bank statement.</param> /// <param name="VendorNo">The vendor number.</param> /// <param name="BankAccountNo">The bank account number.</param> /// <param name="Result">The matching result.</param> /// <param name="IsHandled">Indicates whether the event has been handled.</param> [IntegrationEvent(false, false)] local procedure OnBeforeIsVendorBankAccountMatching(ValueFromBankStatement: Text; VendorNo: Code[20]; BankAccountNo: Code[20]; var Result: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Event raised before matching bank ledger entry documents. /// </summary> /// <param name="SearchText">The text to search for in document matching.</param> /// <param name="TempLedgerEntryMatchingBuffer">The temporary ledger entry matching buffer record.</param> /// <param name="BankPmtApplRule">The bank payment application rule record.</param> [IntegrationEvent(false, false)] local procedure OnDocumentMatchingForBankLedgerEntryOnBeforeMatch(SearchText: Text; TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var BankPmtApplRule: Record "Bank Pmt. Appl. Rule") begin end; /// <summary> /// Event raised before document matching when finding matching entries. /// </summary> /// <param name="BankPmtApplRule">The bank payment application rule record.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="TempLedgerEntryMatchingBuffer">The temporary ledger entry matching buffer record.</param> /// <param name="IsHandled">Indicates whether the event has been handled.</param> /// <param name="TempBankStatementMatchingBuffer">The temporary bank statement matching buffer record.</param> /// <param name="AccountType">The account type for matching.</param> /// <param name="TotalTimeDocumentNoMatching">The total time for document number matching.</param> /// <param name="TotalTimeDocumentNoMatchingForBankLedgerEntry">The total time for bank ledger entry document matching.</param> /// <param name="DocumentMatchedInfoText">The document matching information text.</param> /// <param name="LogInfoText">Indicates whether to log information text.</param> [IntegrationEvent(false, false)] local procedure OnFindMatchingEntryOnBeforeDocumentMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var IsHandled: Boolean; TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer"; AccountType: Enum "Gen. Journal Account Type"; var TotalTimeDocumentNoMatching: Duration; var TotalTimeDocumentNoMatchingForBankLedgerEntry: Duration; var DocumentMatchedInfoText: Text; LogInfoText: Boolean) begin end; /// <summary> /// Event raised before finding the first matching entries in the matching process. /// </summary> /// <param name="TempBankAccReconciliationLine">The temporary bank account reconciliation line record.</param> /// <param name="TempLedgerEntryMatchingBuffer">The temporary ledger entry matching buffer record.</param> /// <param name="AccountType">The account type for matching.</param> /// <param name="SkipOtherEntries">Indicates whether to skip other entries.</param> /// <param name="ApplyEntries">Indicates whether to apply entries automatically.</param> [IntegrationEvent(false, false)] local procedure OnFindMatchingEntriesOnBeforeFindFirst(var TempBankAccReconciliationLine: Record "Bank Acc. Reconciliation Line" temporary; var TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; AccountType: Enum "Gen. Journal Account Type"; var SkipOtherEntries: Boolean; var ApplyEntries: Boolean) begin end; /// <summary> /// Event raised before calculating string nearness when finding text mappings. /// </summary> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="TextToAccountMapping">The text-to-account mapping record.</param> /// <param name="Nearness">The calculated nearness value.</param> [IntegrationEvent(false, false)] local procedure OnFindTextMappingsOnBeforeCalculateStringNearness(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TextToAccountMapping: Record "Text-to-Account Mapping"; var Nearness: Integer); begin end; /// <summary> /// Event raised when setting filters on bank account ledger entries for matching buffer initialization. /// </summary> /// <param name="BankAccountLedgerEntry">The bank account ledger entry record with filters being set.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> [IntegrationEvent(false, false)] local procedure OnInitBankAccLedgerEntriesMatchingBufferSetFilter(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin end; /// <summary> /// Event raised when setting filters on customer ledger entries for matching buffer initialization. /// </summary> /// <param name="CustLedgerEntry">The customer ledger entry record with filters being set.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> [IntegrationEvent(false, false)] local procedure OnInitCustomerLedgerEntriesMatchingBufferSetFilter(var CustLedgerEntry: Record "Cust. Ledger Entry"; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin end; /// <summary> /// Event raised before finding customer ledger entries when initializing the matching buffer. /// </summary> /// <param name="CustLedgerEntry">The customer ledger entry record before finding entries.</param> [IntegrationEvent(false, false)] local procedure OnInitCustomerLedgerEntriesMatchingBufferOnBeforeCustLedgerEntryFindSet(var CustLedgerEntry: Record "Cust. Ledger Entry") begin end; /// <summary> /// Event raised when setting filters on employee ledger entries for matching buffer initialization. /// </summary> /// <param name="EmployeeLedgerEntry">The employee ledger entry record with filters being set.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> [IntegrationEvent(false, false)] local procedure OnInitEmployeeLedgerEntriesMatchingBufferSetFilter(var EmployeeLedgerEntry: Record "Employee Ledger Entry"; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin end; /// <summary> /// Event raised when setting filters on vendor ledger entries for matching buffer initialization. /// </summary> /// <param name="VendorLedgerEntry">The vendor ledger entry record with filters being set.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> [IntegrationEvent(false, false)] local procedure OnInitVendorLedgerEntriesMatchingBufferSetFilter(var VendorLedgerEntry: Record "Vendor Ledger Entry"; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin end; /// <summary> /// Event raised after finding employee ledger entries when initializing the matching buffer. /// </summary> /// <param name="EmployeeLedgerEntry">The employee ledger entry record after finding entries.</param> [IntegrationEvent(false, false)] local procedure OnInitEmployeeLedgerEntriesMatchingBufferOnAfterEmployeeLedgerEntryFindSet(var EmployeeLedgerEntry: Record "Employee Ledger Entry") begin end; /// <summary> /// Event raised after finding vendor ledger entries when initializing the matching buffer. /// </summary> /// <param name="VendorLedgerEntry">The vendor ledger entry record after finding entries.</param> [IntegrationEvent(false, false)] local procedure OnInitVendorLedgerEntriesMatchingBufferOnAfterVendorLedgerEntryFindSet(var VendorLedgerEntry: Record "Vendor Ledger Entry") begin end; /// <summary> /// Event raised after setting the final text when showing match summary. /// </summary> /// <param name="BankAccReconciliation">The bank account reconciliation record.</param> /// <param name="FinalText">The final text to be displayed.</param> /// <param name="IsHandled">Indicates whether the event has been handled.</param> [IntegrationEvent(false, false)] local procedure OnShowMatchSummaryOnAfterSetFinalText(var BankAccReconciliation: Record "Bank Acc. Reconciliation"; FinalText: Text; var IsHandled: Boolean) begin end; /// <summary> /// Event raised after setting filters on payment matching details when deleting payment match details. /// </summary> /// <param name="PaymentMatchingDetails">The payment matching details record with filters set.</param> /// <param name="BankAccReconciliation">The bank account reconciliation record.</param> [IntegrationEvent(false, false)] local procedure OnDeletePaymentMatchDetailsOnAfterPaymentMatchingDetailsSetFilters(var PaymentMatchingDetails: Record "Payment Matching Details"; BankAccReconciliation: Record "Bank Acc. Reconciliation") begin end; /// <summary> /// Event raised after setting filters on applied payment entries when deleting applied payment entries. /// </summary> /// <param name="AppliedPaymentEntry">The applied payment entry record with filters set.</param> /// <param name="BankAccReconciliation">The bank account reconciliation record.</param> [IntegrationEvent(false, false)] local procedure OnDeleteAppliedPaymentEntriesOnAfterAppliedPaymentEntrySetFilters(var AppliedPaymentEntry: Record "Applied Payment Entry"; BankAccReconciliation: Record "Bank Acc. Reconciliation") begin end; /// <summary> /// Event raised to control whether bank ledger entries from closing ledger entries should be disabled from matching. /// </summary> /// <param name="Disable">Indicates whether to disable bank ledger entries matching from closing ledger entries.</param> [IntegrationEvent(false, false)] local procedure OnDisableMatchBankLedgerEntriesFromClosingLedgerEntries(var Disable: boolean) begin end; /// <summary> /// Event raised to control whether string nearness matching should be disabled. /// </summary> /// <param name="Disable">Indicates whether to disable string nearness matching functionality.</param> [IntegrationEvent(false, false)] local procedure OnDisableStringNearnessMatch(var Disable: boolean) begin end; /// <summary> /// Event raised to control whether customer ledger entries matching should be disabled. /// </summary> /// <param name="Disable">Indicates whether to disable customer ledger entries matching functionality.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> [IntegrationEvent(false, false)] local procedure OnDisableCustomerLedgerEntriesMatch(var Disable: boolean; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin end; /// <summary> /// Event raised to control whether vendor ledger entries matching should be disabled. /// </summary> /// <param name="Disable">Indicates whether to disable vendor ledger entries matching functionality.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> [IntegrationEvent(false, false)] local procedure OnDisableVendorLedgerEntriesMatch(var Disable: boolean; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin end; /// <summary> /// Event raised to control whether employee ledger entries matching should be disabled. /// </summary> /// <param name="Disable">Indicates whether to disable employee ledger entries matching functionality.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> [IntegrationEvent(false, false)] local procedure OnDisableEmployeeLedgerEntriesMatch(var Disable: boolean; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin end; /// <summary> /// Event raised to control whether bank ledger entries matching should be disabled. /// </summary> /// <param name="Disable">Indicates whether to disable bank ledger entries matching functionality.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> [IntegrationEvent(false, false)] local procedure OnDisableBankLedgerEntriesMatch(var Disable: boolean; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin end; /// <summary> /// Event raised after calculating total time for document number matching when matching entries. /// </summary> /// <param name="BankPmtApplRule">The bank payment application rule record.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="TempLedgerEntryMatchingBuffer">The temporary ledger entry matching buffer record.</param> /// <param name="AccountType">The account type for matching.</param> /// <param name="TempBankStatementMatchingBuffer">The temporary bank statement matching buffer record.</param> /// <param name="TotalTimeRelatedPartyMatching">The total time for related party matching.</param> /// <param name="TotalTimeAmountMatching">The total time for amount matching.</param> /// <param name="RemainingAmount">The remaining amount after matching.</param> /// <param name="RelatedPartyMatchedInfoText">The related party matching information text.</param> /// <param name="LogInfoText">Indicates whether to log information text.</param> /// <param name="TotalTimeStringNearness">The total time for string nearness matching.</param> /// <param name="UsePaymentDiscounts">Indicates whether to use payment discounts.</param> /// <param name="OneToManyTempBankStatementMatchingBuffer">The one-to-many temporary bank statement matching buffer record.</param> /// <param name="TempCustomerLedgerEntryMatchingBuffer">The temporary customer ledger entry matching buffer record.</param> /// <param name="TempVendorLedgerEntryMatchingBuffer">The temporary vendor ledger entry matching buffer record.</param> /// <param name="TempEmployeeLedgerEntryMatchingBuffer">The temporary employee ledger entry matching buffer record.</param> /// <param name="TempBankAccLedgerEntryMatchingBuffer">The temporary bank account ledger entry matching buffer record.</param> /// <param name="IsHandled">Indicates whether the event has been handled.</param> /// <param name="DocumentMatchedInfoText">The document matching information text.</param> [IntegrationEvent(false, false)] local procedure OnMatchEntriesOnAfterCalcTotalTimeDocumentNoMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; TempLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; AccountType: Enum "Gen. Journal Account Type"; TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var TotalTimeRelatedPartyMatching: Duration; var TotalTimeAmountMatching: Duration; var RemainingAmount: Decimal; var RelatedPartyMatchedInfoText: Text; LogInfoText: Boolean; var TotalTimeStringNearness: Duration; UsePaymentDiscounts: Boolean; OneToManyTempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var TempCustomerLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var TempVendorLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var TempEmployeeLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var TempBankAccLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var IsHandled: Boolean; var DocumentMatchedInfoText: Text) begin end; /// <summary> /// Event raised during related party information matching process. /// </summary> /// <param name="BankPmtApplRule">The bank payment application rule record.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="Name">The name value for matching.</param> /// <param name="Address">The address value for matching.</param> /// <param name="City">The city value for matching.</param> /// <param name="AccountType">The account type for matching.</param> /// <param name="RelatedPartyMatchedInfoText">The related party matching information text.</param> /// <param name="Handled">Indicates whether the related party matching has been handled.</param> [IntegrationEvent(false, false)] local procedure OnRelatedPartyInfoMatching(var BankPmtApplRule: Record "Bank Pmt. Appl. Rule"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; Name: Text[100]; Address: Text[100]; City: Text[30]; AccountType: Enum "Gen. Journal Account Type"; var RelatedPartyMatchedInfoText: Text; var Handled: Boolean) begin end; /// <summary> /// Event raised when finding bank account ledger entry for text-to-account mapping. /// </summary> /// <param name="Handled">Indicates whether the finding process has been handled.</param> /// <param name="Found">Indicates whether a matching bank account ledger entry was found.</param> /// <param name="BankAccLedgerEntry">The bank account ledger entry record found for mapping.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="TextToAccountMapping">The text-to-account mapping record.</param> /// <param name="BalAccountNo">The balance account number.</param> [IntegrationEvent(false, false)] local procedure OnFindBankAccLedgerEntryForTextToAccountMapping(var Handled: Boolean; var Found: Boolean; var BankAccLedgerEntry: Record "Bank Account Ledger Entry"; BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; TextToAccountMapping: Record "Text-to-Account Mapping"; BalAccountNo: Code[20]) begin end; /// <summary> /// Event raised after setting filters on the second bank account reconciliation line record when updating payment match details. /// </summary> /// <param name="BankAccReconciliationLine2">The second bank account reconciliation line record with filters set.</param> /// <param name="BankAccReconciliationLine">The primary bank account reconciliation line record.</param> [IntegrationEvent(false, false)] local procedure OnUpdatePaymentMatchDetailsOnAfterBankAccReconciliationLine2SetFilters(var BankAccReconciliationLine2: Record "Bank Acc. Reconciliation Line"; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line") begin end; /// <summary> /// Event raised before finding the temporary bank statement matching buffer when creating applied entries. /// </summary> /// <param name="BankAccReconciliation">The bank account reconciliation record.</param> /// <param name="TempBankStatementMatchingBuffer">The temporary bank statement matching buffer record.</param> /// <param name="TempBankStmtMultipleMatchLine">The temporary bank statement multiple match line record.</param> [IntegrationEvent(false, false)] local procedure OnCreateAppliedEntriesOnBeforeTempBankStatementMatchingBufferFindset(BankAccReconciliation: Record "Bank Acc. Reconciliation"; var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var TempBankStmtMultipleMatchLine: Record "Bank Stmt Multiple Match Line" temporary) begin end; /// <summary> /// Event raised before checking if entries can match based on specified criteria. /// </summary> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="Amount">The amount to match.</param> /// <param name="EntryPostingDate">The entry posting date.</param> /// <param name="ApplyEntries">Indicates whether to apply entries automatically.</param> /// <param name="Result">The result of the matching check.</param> /// <param name="IsHandled">Indicates whether the event has been handled.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCanEntriesMatch(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; Amount: Decimal; EntryPostingDate: Date; ApplyEntries: Boolean; var Result: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Event raised after updating payment match details when applying ledger entries to statement lines. /// </summary> /// <param name="BankAccReconciliation">The bank account reconciliation record.</param> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="Overwrite">Indicates whether to overwrite existing match details.</param> [IntegrationEvent(false, false)] local procedure OnApplyLedgerEntriesToStatementLinesOnAfterUpdatePaymentMatchDetails(BankAccReconciliation: Record "Bank Acc. Reconciliation"; var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; Overwrite: Boolean) begin end; /// <summary> /// Event raised after calculating total time for text mappings per line when mapping ledger entries to statement lines. /// </summary> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="TempBankStatementMatchingBuffer">The temporary bank statement matching buffer record.</param> /// <param name="TotalTimeMatchingCustomerLedgerEntriesPerLine">The total time for matching customer ledger entries per line.</param> /// <param name="TotalTimeMatchingVendorLedgerEntriesPerLine">The total time for matching vendor ledger entries per line.</param> /// <param name="TotalTimeMatchingEmployeeLedgerEntriesPerLine">The total time for matching employee ledger entries per line.</param> /// <param name="TotalTimeMatchingBankLedgerEntriesPerLine">The total time for matching bank ledger entries per line.</param> /// <param name="RelatedPartyMatchedInfoText">The related party matching information text.</param> /// <param name="LogInfoText">Indicates whether to log information text.</param> /// <param name="TotalTimeStringNearness">The total time for string nearness matching.</param> /// <param name="UsePaymentDiscounts">Indicates whether to use payment discounts.</param> /// <param name="OneToManyTempBankStatementMatchingBuffer">The one-to-many temporary bank statement matching buffer record.</param> /// <param name="TempCustomerLedgerEntryMatchingBuffer">The temporary customer ledger entry matching buffer record.</param> /// <param name="TempVendorLedgerEntryMatchingBuffer">The temporary vendor ledger entry matching buffer record.</param> /// <param name="TempEmployeeLedgerEntryMatchingBuffer">The temporary employee ledger entry matching buffer record.</param> /// <param name="TempBankAccLedgerEntryMatchingBuffer">The temporary bank account ledger entry matching buffer record.</param> [IntegrationEvent(false, false)] local procedure OnMapLedgerEntriesToStatementLinesOnAfterCalcTotalTimeTimeTextMappingsPerLine(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var TotalTimeMatchingCustomerLedgerEntriesPerLine: Duration; var TotalTimeMatchingVendorLedgerEntriesPerLine: Duration; var TotalTimeMatchingEmployeeLedgerEntriesPerLine: Duration; var TotalTimeMatchingBankLedgerEntriesPerLine: Duration; var RelatedPartyMatchedInfoText: Text; LogInfoText: Boolean; var TotalTimeStringNearness: Duration; UsePaymentDiscounts: Boolean; OneToManyTempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary; var TempCustomerLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var TempVendorLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var TempEmployeeLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary; var TempBankAccLedgerEntryMatchingBuffer: Record "Ledger Entry Matching Buffer" temporary) begin end; /// <summary> /// Event raised before inserting a bank account reconciliation line when transferring differences to an account. /// </summary> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record to be inserted.</param> /// <param name="TempGenJournalLine">The temporary general journal line record.</param> [IntegrationEvent(false, false)] local procedure OnTransferDiffToAccountOnBeforeInsertBankAccReconciliationLine(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; TempGenJournalLine: Record "Gen. Journal Line" temporary) begin end; /// <summary> /// Event raised after sending trace tag when applying records. /// </summary> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="TempBankStatementMatchingBuffer">The temporary bank statement matching buffer record.</param> [IntegrationEvent(false, false)] local procedure OnApplyRecordsOnAfterSendTraceTag(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary); begin end; /// <summary> /// Event raised after text mapper has matched when finding text mappings. /// </summary> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="TextToAccountMapping">The text-to-account mapping record that was matched.</param> /// <param name="TempBankStatementMatchingBuffer">The temporary bank statement matching buffer record.</param> [IntegrationEvent(false, false)] local procedure OnFindTextMappingsOnAfterTextMapperMatched(var BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TextToAccountMapping: Record "Text-to-Account Mapping"; var TempBankStatementMatchingBuffer: Record "Bank Statement Matching Buffer" temporary); begin end; /// <summary> /// Event raised before editing a customer ledger entry when setting customer application data. /// </summary> /// <param name="CustLedgerEntry">The customer ledger entry record to be edited.</param> [IntegrationEvent(false, false)] local procedure OnSetCustAppicationDataOnBeforeCustEntryEdit(var CustLedgerEntry: Record "Cust. Ledger Entry") begin end; /// <summary> /// Event raised when transferring difference amounts to accounts during bank reconciliation. /// </summary> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="TempGenJnlLine">The temporary general journal line record for transferring differences.</param> /// <param name="DifferenceTransferred">Indicates whether the difference has been transferred.</param> [IntegrationEvent(false, false)] local procedure OnTransferDifference(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var TempGenJnlLine: Record "Gen. Journal Line" temporary; var DifferenceTransferred: Boolean) begin end; /// <summary> /// Event raised before editing a vendor ledger entry when setting vendor application data. /// </summary> /// <param name="VendorLedgerEntry">The vendor ledger entry record to be edited.</param> [IntegrationEvent(false, false)] local procedure OnSetVendAppicationDataOnBeforeVendEntryEdit(var VendorLedgerEntry: Record "Vendor Ledger Entry") begin end; /// <summary> /// Event raised before showing the line split message during bank reconciliation. /// </summary> /// <param name="BankAccReconciliationLine">The bank account reconciliation line record.</param> /// <param name="SuppressMessage">Indicates whether to suppress the line split message.</param> [IntegrationEvent(false, false)] local procedure OnBeforeShowLineSplitMessage(BankAccReconciliationLine: Record "Bank Acc. Reconciliation Line"; var SuppressMessage: Boolean) begin end;}#pragma warning restore AA0198