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