Codeunit 225 Gen. Jnl.-Apply

Base Application, Microsoft.Finance.ReceivablesPayables

src/Layers/W1/BaseApp/Finance/ReceivablesPayables/GenJnlApply.Codeunit.al1,294 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.Finance.ReceivablesPayables;using Microsoft.Finance.Currency;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.HumanResources.Payables;using Microsoft.Purchases.Payables;using Microsoft.Purchases.Setup;using Microsoft.Purchases.Vendor;using Microsoft.Sales.Receivables;using Microsoft.Sales.Setup;using System.Utilities;/// <summary>/// Handles application of general journal lines to customer, vendor, and employee ledger entries./// Provides payment application functionality with automatic settlement calculation and currency handling./// </summary>/// <remarks>/// Primary application engine for general journal posting with ledger entry application./// Supports multi-currency applications with exchange rate validation and payment tolerance handling./// Integrates with customer, vendor, and employee ledger entry application processes./// Extensible through application events for custom settlement logic and validation./// </remarks>codeunit 225 "Gen. Jnl.-Apply"{    TableNo = "Gen. Journal Line";    trigger OnRun()    var        IsHandled: Boolean;    begin        GenJnlLine.Copy(Rec);        IsHandled := false;        OnBeforeRun(GenJnlLine, IsHandled);        if IsHandled then            exit;        GetCurrency();        if GenJnlLine."Bal. Account Type" in           [GenJnlLine."Bal. Account Type"::Customer, GenJnlLine."Bal. Account Type"::Vendor, GenJnlLine."Bal. Account Type"::Employee]        then begin            AccType := GenJnlLine."Bal. Account Type";            AccNo := GenJnlLine."Bal. Account No.";        end else begin            AccType := GenJnlLine."Account Type";            AccNo := GenJnlLine."Account No.";        end;        case AccType of            AccType::Customer:                ApplyCustomerLedgerEntry(GenJnlLine);            AccType::Vendor:                ApplyVendorLedgerEntry(GenJnlLine);            AccType::Employee:                ApplyEmployeeLedgerEntry(GenJnlLine);            else                Error(                  Text005,                  GenJnlLine.FieldCaption("Account Type"), GenJnlLine.FieldCaption("Bal. Account Type"));        end;        OnAfterRun(GenJnlLine);        Rec := GenJnlLine;    end;    var        GenJnlLine: Record "Gen. Journal Line";        GLSetup: Record "General Ledger Setup";        Currency: Record Currency;        CurrExchRate: Record "Currency Exchange Rate";        PaymentToleranceMgt: Codeunit "Payment Tolerance Management";        AccNo: Code[20];        CurrencyCode2: Code[10];        EntrySelected: Boolean;        AccType: Enum "Gen. Journal Account Type";#pragma warning disable AA0074#pragma warning disable AA0470        Text000: Label 'You must specify %1 or %2.';#pragma warning restore AA0470#pragma warning restore AA0074        ConfirmChangeQst: Label 'CurrencyCode in the %1 will be changed from %2 to %3.\Do you wish to continue?', Comment = '%1 = Table Name, %2 and %3 = Currency Code';        UpdateInterruptedErr: Label 'The update has been interrupted to respect the warning.';#pragma warning disable AA0074#pragma warning disable AA0470        Text005: Label 'The %1 or %2 must be Customer or Vendor.';#pragma warning restore AA0470        Text006: Label 'All entries in one application must be in the same currency.';        Text007: Label 'All entries in one application must be in the same currency or one or more of the EMU currencies. ';#pragma warning restore AA0074        EarlierPostingDateErr: Label 'You cannot apply and post an entry to an entry with an earlier posting date. Instead, post the document of type %1 with the number %2 and then apply it to the document of type %3 with the number %4.', Comment = '%1 = Applying document type, %2 = Applying document number, %3 = Entry document type, %4 = Entry document number';    local procedure SelectCustLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var CustomAppliesToId: Code[50]) Selected: Boolean    var        CustLedgEntry: Record "Cust. Ledger Entry";        ApplyCustEntries: Page "Apply Customer Entries";        PreviousAppliesToID: Code[50];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSelectCustLedgEntry(GenJnlLine, AccNo, Selected, IsHandled, CustomAppliesToId);        if IsHandled then            exit(Selected);        CustLedgEntry.SetCurrentKey("Customer No.", Open, Positive);        CustLedgEntry.SetRange("Customer No.", AccNo);        CustLedgEntry.SetRange(Open, true);        OnSelectCustLedgEntryOnAfterSetFilters(CustLedgEntry, GenJnlLine);        PreviousAppliesToID := GenJnlLine."Applies-to ID";        if GenJnlLine."Applies-to ID" = '' then            GenJnlLine."Applies-to ID" := GenJnlLine."Document No.";        if GenJnlLine."Applies-to ID" = '' then            Error(              Text000,              GenJnlLine.FieldCaption("Document No."), GenJnlLine.FieldCaption("Applies-to ID"));        ApplyCustEntries.SetGenJnlLine(GenJnlLine, GenJnlLine.FieldNo("Applies-to ID"));        ApplyCustEntries.SetRecord(CustLedgEntry);        ApplyCustEntries.SetTableView(CustLedgEntry);        ApplyCustEntries.LookupMode(true);        Selected := ApplyCustEntries.RunModal() = ACTION::LookupOK;        if not Selected then            GenJnlLine."Applies-to ID" := PreviousAppliesToID;        CustomAppliesToId := ApplyCustEntries.GetCustomAppliesToID();        Clear(ApplyCustEntries);        OnAfterSelectCustLedgEntry(GenJnlLine, AccNo, Selected);    end;    local procedure SelectVendLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var CustomAppliesToId: Code[50]) Selected: Boolean    var        VendLedgEntry: Record "Vendor Ledger Entry";        ApplyVendEntries: Page "Apply Vendor Entries";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSelectVendLedgEntry(GenJnlLine, AccNo, Selected, IsHandled, CustomAppliesToId);        if IsHandled then            exit(Selected);        VendLedgEntry.SetCurrentKey("Vendor No.", Open, Positive);        VendLedgEntry.SetRange("Vendor No.", AccNo);        VendLedgEntry.SetRange(Open, true);        OnSelectVendLedgEntryOnAfterSetFilters(VendLedgEntry, GenJnlLine);        if GenJnlLine."Applies-to ID" = '' then            GenJnlLine."Applies-to ID" := GenJnlLine."Document No.";        if GenJnlLine."Applies-to ID" = '' then            Error(              Text000,              GenJnlLine.FieldCaption("Document No."), GenJnlLine.FieldCaption("Applies-to ID"));        ApplyVendEntries.SetGenJnlLine(GenJnlLine, GenJnlLine.FieldNo("Applies-to ID"));        ApplyVendEntries.SetRecord(VendLedgEntry);        ApplyVendEntries.SetTableView(VendLedgEntry);        ApplyVendEntries.LookupMode(true);        Selected := ApplyVendEntries.RunModal() = ACTION::LookupOK;        CustomAppliesToId := ApplyVendEntries.GetCustomAppliesToID();        Clear(ApplyVendEntries);        OnAfterSelectVendLedgEntry(GenJnlLine, AccNo, Selected);    end;    local procedure SelectEmplLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var CustomAppliesToId: Code[50]) Selected: Boolean    var        EmplLedgEntry: Record "Employee Ledger Entry";        ApplyEmplEntries: Page "Apply Employee Entries";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSelectEmplLedgEntry(GenJnlLine, AccNo, Selected, IsHandled);        if IsHandled then            exit(Selected);        EmplLedgEntry.SetCurrentKey("Employee No.", Open, Positive);        EmplLedgEntry.SetRange("Employee No.", AccNo);        EmplLedgEntry.SetRange(Open, true);        OnSelectEmplLedgEntryOnAfterSetFilters(EmplLedgEntry, GenJnlLine);        if GenJnlLine."Applies-to ID" = '' then            GenJnlLine."Applies-to ID" := GenJnlLine."Document No.";        if GenJnlLine."Applies-to ID" = '' then            Error(              Text000,              GenJnlLine.FieldCaption("Document No."), GenJnlLine.FieldCaption("Applies-to ID"));        ApplyEmplEntries.SetGenJnlLine(GenJnlLine, GenJnlLine.FieldNo("Applies-to ID"));        ApplyEmplEntries.SetRecord(EmplLedgEntry);        ApplyEmplEntries.SetTableView(EmplLedgEntry);        ApplyEmplEntries.LookupMode(true);        Selected := ApplyEmplEntries.RunModal() = ACTION::LookupOK;        CustomAppliesToId := ApplyEmplEntries.GetCustomAppliesToID();        Clear(ApplyEmplEntries);        OnAfterSelectEmplLedgEntry(GenJnlLine, AccNo, Selected);    end;    local procedure UpdateCustLedgEntry(var CustLedgEntry: Record "Cust. Ledger Entry")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateCustLedgEntry(CustLedgEntry, GenJnlLine, IsHandled);        if IsHandled then            exit;        CustLedgEntry.CalcFields("Remaining Amount");        CustLedgEntry."Remaining Amount" :=          CurrExchRate.ExchangeAmount(            CustLedgEntry."Remaining Amount", CustLedgEntry."Currency Code", GenJnlLine."Currency Code", GenJnlLine."Posting Date");        CustLedgEntry."Remaining Amount" :=          Round(CustLedgEntry."Remaining Amount", Currency."Amount Rounding Precision");        CustLedgEntry."Remaining Pmt. Disc. Possible" :=          CurrExchRate.ExchangeAmount(            CustLedgEntry."Remaining Pmt. Disc. Possible", CustLedgEntry."Currency Code", GenJnlLine."Currency Code", GenJnlLine."Posting Date");        CustLedgEntry."Remaining Pmt. Disc. Possible" :=          Round(CustLedgEntry."Remaining Pmt. Disc. Possible", Currency."Amount Rounding Precision");        CustLedgEntry."Amount to Apply" :=          CurrExchRate.ExchangeAmount(            CustLedgEntry."Amount to Apply", CustLedgEntry."Currency Code", GenJnlLine."Currency Code", GenJnlLine."Posting Date");        CustLedgEntry."Amount to Apply" :=          Round(CustLedgEntry."Amount to Apply", Currency."Amount Rounding Precision");    end;    local procedure UpdateVendLedgEntry(var VendLedgEntry: Record "Vendor Ledger Entry")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateVendLedgEntry(VendLedgEntry, GenJnlLine, IsHandled);        if IsHandled then            exit;        VendLedgEntry.CalcFields("Remaining Amount");        VendLedgEntry."Remaining Amount" :=          CurrExchRate.ExchangeAmount(            VendLedgEntry."Remaining Amount", VendLedgEntry."Currency Code", GenJnlLine."Currency Code", GenJnlLine."Posting Date");        VendLedgEntry."Remaining Amount" :=          Round(VendLedgEntry."Remaining Amount", Currency."Amount Rounding Precision");        VendLedgEntry."Remaining Pmt. Disc. Possible" :=          CurrExchRate.ExchangeAmount(            VendLedgEntry."Remaining Pmt. Disc. Possible", VendLedgEntry."Currency Code", GenJnlLine."Currency Code", GenJnlLine."Posting Date");        VendLedgEntry."Remaining Pmt. Disc. Possible" :=          Round(VendLedgEntry."Remaining Pmt. Disc. Possible", Currency."Amount Rounding Precision");        VendLedgEntry."Amount to Apply" :=          CurrExchRate.ExchangeAmount(            VendLedgEntry."Amount to Apply", VendLedgEntry."Currency Code", GenJnlLine."Currency Code", GenJnlLine."Posting Date");        VendLedgEntry."Amount to Apply" :=          Round(VendLedgEntry."Amount to Apply", Currency."Amount Rounding Precision");        OnAfterUpdateVendLedgEntry(GenJnlLine, VendLedgEntry);    end;    local procedure UpdateEmployeeLedgEntry(var EmplLedgEntry: Record "Employee Ledger Entry")    begin        EmplLedgEntry.CalcFields("Remaining Amount");        EmplLedgEntry."Remaining Amount" :=          CurrExchRate.ExchangeAmount(            EmplLedgEntry."Remaining Amount", EmplLedgEntry."Currency Code", GenJnlLine."Currency Code", GenJnlLine."Posting Date");        EmplLedgEntry."Remaining Amount" :=          Round(EmplLedgEntry."Remaining Amount", Currency."Amount Rounding Precision");        EmplLedgEntry."Amount to Apply" :=          CurrExchRate.ExchangeAmount(            EmplLedgEntry."Amount to Apply", EmplLedgEntry."Currency Code", GenJnlLine."Currency Code", GenJnlLine."Posting Date");        EmplLedgEntry."Amount to Apply" :=          Round(EmplLedgEntry."Amount to Apply", Currency."Amount Rounding Precision");    end;    /// <summary>    /// Validates currency compatibility between application currency and comparison currency for payment applications.    /// Checks application between currencies setup and EMU currency configuration.    /// </summary>    /// <param name="ApplnCurrencyCode">Currency code of the payment being applied</param>    /// <param name="CompareCurrencyCode">Currency code to compare against</param>    /// <param name="AccType">Account type for determining applicable setup</param>    /// <param name="Message">Whether to show error messages for validation failures</param>    /// <returns>True if currencies are compatible for application, false otherwise</returns>    procedure CheckAgainstApplnCurrency(ApplnCurrencyCode: Code[10]; CompareCurrencyCode: Code[10]; AccType: Enum "Gen. Journal Account Type"; Message: Boolean): Boolean    var        Currency: Record Currency;        Currency2: Record Currency;        SalesSetup: Record "Sales & Receivables Setup";        PurchSetup: Record "Purchases & Payables Setup";        CurrencyAppln: Option No,EMU,All;    begin        OnBeforeCheckAgainstApplnCurrency(ApplnCurrencyCode, CompareCurrencyCode);        if ApplnCurrencyCode = CompareCurrencyCode then            exit(true);        case AccType of            AccType::Customer:                begin                    SalesSetup.Get();                    CurrencyAppln := SalesSetup."Appln. between Currencies";                    case CurrencyAppln of                        CurrencyAppln::No:                            if ApplnCurrencyCode <> CompareCurrencyCode then                                if Message then                                    Error(Text006)                                else                                    exit(false);                        CurrencyAppln::EMU:                            begin                                GLSetup.Get();                                if not Currency.Get(ApplnCurrencyCode) then                                    Currency."EMU Currency" := GLSetup."EMU Currency";                                if not Currency2.Get(CompareCurrencyCode) then                                    Currency2."EMU Currency" := GLSetup."EMU Currency";                                if not Currency."EMU Currency" or not Currency2."EMU Currency" then                                    if Message then                                        Error(Text007)                                    else                                        exit(false);                            end;                    end;                end;            AccType::Vendor:                begin                    PurchSetup.Get();                    CurrencyAppln := PurchSetup."Appln. between Currencies";                    case CurrencyAppln of                        CurrencyAppln::No:                            if ApplnCurrencyCode <> CompareCurrencyCode then                                if Message then                                    Error(Text006)                                else                                    exit(false);                        CurrencyAppln::EMU:                            begin                                GLSetup.Get();                                if not Currency.Get(ApplnCurrencyCode) then                                    Currency."EMU Currency" := GLSetup."EMU Currency";                                if not Currency2.Get(CompareCurrencyCode) then                                    Currency2."EMU Currency" := GLSetup."EMU Currency";                                if not Currency."EMU Currency" or not Currency2."EMU Currency" then                                    if Message then                                        Error(Text007)                                    else                                        exit(false);                            end;                    end;                end;        end;        exit(true);    end;    local procedure GetCurrency()    begin        if GenJnlLine."Currency Code" = '' then            Currency.InitRoundingPrecision()        else begin            Currency.Get(GenJnlLine."Currency Code");            Currency.TestField("Amount Rounding Precision");        end;    end;    local procedure ApplyCustomerLedgerEntry(var GenJnlLine: Record "Gen. Journal Line")    var        CustLedgEntry: Record "Cust. Ledger Entry";        TempCustLedgEntry: Record "Cust. Ledger Entry" temporary;        AppliedAmount: Decimal;        CustomAppliesToId: Code[50];        IsHandled: Boolean;    begin        GetAppliedCustomerEntries(TempCustLedgEntry, GenJnlLine);        EntrySelected := SelectCustLedgEntry(GenJnlLine, CustomAppliesToId);        if not EntrySelected then            exit;        CustLedgEntry.Reset();        CustLedgEntry.SetCurrentKey("Customer No.", Open, Positive);        CustLedgEntry.SetRange("Customer No.", AccNo);        CustLedgEntry.SetRange(Open, true);        CustLedgEntry.SetRange("Applies-to ID", GenJnlLine."Applies-to ID");        IsHandled := false;        OnAfterCustLedgEntrySetFilters(CustLedgEntry, GenJnlLine, AccNo, CustomAppliesToId, IsHandled);        if IsHandled then            exit;        if CustLedgEntry.Find('-') then begin            CurrencyCode2 := CustLedgEntry."Currency Code";            if GenJnlLine.Amount = 0 then begin                repeat                    if not TempCustLedgEntry.Get(CustLedgEntry."Entry No.") then begin                        PaymentToleranceMgt.DelPmtTolApllnDocNo(GenJnlLine, CustLedgEntry."Document No.");                        OnApplyCustomerLedgerEntryOnBeforeCheckAgainstApplnCurrency(GenJnlLine, CustLedgEntry);                        CheckAgainstApplnCurrency(CurrencyCode2, CustLedgEntry."Currency Code", AccType::Customer, true);                        UpdateCustLedgEntry(CustLedgEntry);                        IsHandled := false;                        OnBeforeFindCustApply(GenJnlLine, CustLedgEntry, GenJnlLine.Amount, IsHandled);                        if not IsHandled then                            if PaymentToleranceMgt.CheckCalcPmtDiscGenJnlCust(GenJnlLine, CustLedgEntry, 0, false) and                               (Abs(CustLedgEntry."Amount to Apply") >=                                Abs(CustLedgEntry."Remaining Amount" - CustLedgEntry.GetRemainingPmtDiscPossible(GenJnlLine."Posting Date")))                            then                                GenJnlLine.Amount := GenJnlLine.Amount - (CustLedgEntry."Amount to Apply" - CustLedgEntry.GetRemainingPmtDiscPossible(GenJnlLine."Posting Date"))                            else                                GenJnlLine.Amount := GenJnlLine.Amount - CustLedgEntry."Amount to Apply";                    end else                        GetAppliedAmountOnCustLedgerEntry(TempCustLedgEntry, AppliedAmount);                until CustLedgEntry.Next() = 0;                TempCustLedgEntry.DeleteAll();                if AppliedAmount <> 0 then                    GenJnlLine.Amount += AppliedAmount;                if (GenJnlLine."Bal. Account Type" = GenJnlLine."Bal. Account Type"::Customer) or (GenJnlLine."Bal. Account Type" = GenJnlLine."Bal. Account Type"::Vendor) then                    GenJnlLine.Amount := -GenJnlLine.Amount;                GenJnlLine.Validate(Amount);                OnApplyCustomerLedgerEntryOnAfterValidateAmount(GenJnlLine, CustLedgEntry);            end else                repeat                    OnApplyCustomerLedgerEntryOnBeforeCheckAgainstApplnCurrencyCustomerAmountNotZero(GenJnlLine, CustLedgEntry);                    CheckAgainstApplnCurrency(CurrencyCode2, CustLedgEntry."Currency Code", AccType::Customer, true);                until CustLedgEntry.Next() = 0;            if GenJnlLine."Currency Code" <> CurrencyCode2 then                if GenJnlLine.Amount = 0 then begin                    IsHandled := false;                    OnApplyCustomerLedgerEntryOnBeforeConfirmUpdateCurrency(GenJnlLine, CustLedgEntry."Currency Code", IsHandled);                    if not IsHandled then begin                        ConfirmCurrencyUpdate(GenJnlLine, CustLedgEntry."Currency Code");                        GenJnlLine."Currency Code" := CustLedgEntry."Currency Code";                    end;                end else begin                    OnApplyCustomerLedgerEntryOnBeforeCheckAgainstApplnCurrencyCustomer(GenJnlLine, CustLedgEntry);                    CheckAgainstApplnCurrency(GenJnlLine."Currency Code", CustLedgEntry."Currency Code", AccType::Customer, true);                end;            GenJnlLine."Applies-to Doc. Type" := GenJnlLine."Applies-to Doc. Type"::" ";            GenJnlLine."Applies-to Doc. No." := '';            OnApplyCustomerLedgerEntryOnAfterSetCustomerAppliesToDocNo(GenJnlLine, CustLedgEntry);        end else            GenJnlLine."Applies-to ID" := '';        if (GenJnlLine."Applies-to ID" = '') and (CustomAppliesToId <> '') then            GenJnlLine."Applies-to ID" := CustomAppliesToId;        GenJnlLine.SetJournalLineFieldsFromApplication();        OnApplyCustomerLedgerEntryOnBeforeModify(GenJnlLine, CustLedgEntry);        if GenJnlLine.Modify() then;        if GenJnlLine.Amount <> 0 then            if not PaymentToleranceMgt.PmtTolGenJnl(GenJnlLine) then                exit;    end;    /// <summary>    /// Sets vendor application ID for API-based vendor ledger entry applications.    /// Validates currency compatibility and updates vendor ledger entry for application.    /// </summary>    /// <param name="GenJournalLine">General journal line containing payment information</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry to apply payment against</param>    procedure SetVendApplIdAPI(GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry")    var        TempApplyingVendorLedgerEntry: Record "Vendor Ledger Entry" temporary;        Vendor: Record Vendor;        GenJnlApply: Codeunit "Gen. Jnl.-Apply";        VendEntrySetApplID: Codeunit "Vend. Entry-SetAppl.ID";        ApplnCurrencyCode: Code[10];    begin        if GenJournalLine."Applies-to ID" = '' then            GenJournalLine."Applies-to ID" := GenJournalLine."Document No.";        if GenJournalLine."Applies-to ID" = '' then            Error(              Text000,              GenJournalLine.FieldCaption("Document No."), GenJournalLine.FieldCaption("Applies-to ID"));        ApplnCurrencyCode := GenJournalLine."Currency Code";        TempApplyingVendorLedgerEntry."Posting Date" := GenJournalLine."Posting Date";        TempApplyingVendorLedgerEntry."Document Type" := GenJournalLine."Document Type";        TempApplyingVendorLedgerEntry."Document No." := GenJournalLine."Document No.";        if GenJournalLine."Bal. Account Type" = GenJournalLine."Bal. Account Type"::Vendor then begin            TempApplyingVendorLedgerEntry."Vendor No." := GenJournalLine."Bal. Account No.";            Vendor.Get(TempApplyingVendorLedgerEntry."Vendor No.");            TempApplyingVendorLedgerEntry.Description := Vendor.Name;        end else begin            TempApplyingVendorLedgerEntry."Vendor No." := GenJournalLine."Account No.";            TempApplyingVendorLedgerEntry.Description := GenJournalLine.Description;        end;        TempApplyingVendorLedgerEntry."Currency Code" := GenJournalLine."Currency Code";        TempApplyingVendorLedgerEntry.Amount := GenJournalLine.Amount;        TempApplyingVendorLedgerEntry."Remaining Amount" := GenJournalLine.Amount;        OnSetVendApplIdAPIOnBeforeCheckPostingDate(TempApplyingVendorLedgerEntry, GenJournalLine, VendorLedgerEntry);        if TempApplyingVendorLedgerEntry."Posting Date" < VendorLedgerEntry."Posting Date" then            Error(                EarlierPostingDateErr, TempApplyingVendorLedgerEntry."Document Type", TempApplyingVendorLedgerEntry."Document No.",                VendorLedgerEntry."Document Type", VendorLedgerEntry."Document No.");        if TempApplyingVendorLedgerEntry."Entry No." <> 0 then begin            OnSetVendApplIdAPIOnBeforeCheckAgainstApplnCurrency(GenJournalLine, VendorLedgerEntry);            GenJnlApply.CheckAgainstApplnCurrency(                ApplnCurrencyCode, VendorLedgerEntry."Currency Code", GenJournalLine."Account Type"::Vendor, true);        end;        VendorLedgerEntry.SetRange("Entry No.", VendorLedgerEntry."Entry No.");        VendorLedgerEntry.SetRange("Vendor No.", VendorLedgerEntry."Vendor No.");        VendEntrySetApplID.SetApplId(VendorLedgerEntry, TempApplyingVendorLedgerEntry, GenJournalLine."Applies-to ID");    end;    /// <summary>    /// Applies vendor ledger entries through API with comprehensive validation and currency checking.    /// Processes application IDs and validates currency compatibility for API-based applications.    /// </summary>    /// <param name="GenJournalLine">General journal line with application information</param>    procedure ApplyVendorLedgerEntryAPI(var GenJournalLine: Record "Gen. Journal Line")    var        VendorLedgerEntry: Record "Vendor Ledger Entry";        TempVendorLedgerEntry: Record "Vendor Ledger Entry" temporary;    begin        GenJnlLine.Copy(GenJournalLine);        GetCurrency();        GenJnlLine.GetAccTypeAndNo(GenJnlLine, AccType, AccNo);        GetAppliedVendorEntries(TempVendorLedgerEntry, GenJnlLine);        GenJnlLine."Applies-to ID" := GenJnlLine."Document No.";        VendorLedgerEntry.Reset();        VendorLedgerEntry.SetCurrentKey("Vendor No.", Open, Positive);        VendorLedgerEntry.SetRange("Vendor No.", AccNo);        VendorLedgerEntry.SetRange(Open, true);        VendorLedgerEntry.SetRange("Applies-to ID", GenJnlLine."Document No.");        if VendorLedgerEntry.Find('-') then begin            CurrencyCode2 := VendorLedgerEntry."Currency Code";            if GenJnlLine.Amount = 0 then begin                repeat                    if not TempVendorLedgerEntry.Get(VendorLedgerEntry."Entry No.") then begin                        PaymentToleranceMgt.DelPmtTolApllnDocNo(GenJnlLine, VendorLedgerEntry."Document No.");                        OnApplyVendorLedgerEntryAPIOnBeforeCheckAgainstApplnCurrencyAmountZero(GenJnlLine, VendorLedgerEntry);                        CheckAgainstApplnCurrency(CurrencyCode2, VendorLedgerEntry."Currency Code", AccType::Vendor, true);                        UpdateVendLedgEntry(VendorLedgerEntry);                        if PaymentToleranceMgt.CheckCalcPmtDiscGenJnlVend(GenJnlLine, VendorLedgerEntry, 0, false) and                           (Abs(VendorLedgerEntry."Amount to Apply") >=                            Abs(VendorLedgerEntry."Remaining Amount" - VendorLedgerEntry.GetRemainingPmtDiscPossible(GenJnlLine."Posting Date")))                        then                            GenJnlLine.Amount := GenJnlLine.Amount - (VendorLedgerEntry."Amount to Apply" - VendorLedgerEntry."Remaining Pmt. Disc. Possible")                        else                            GenJnlLine.Amount := GenJnlLine.Amount - VendorLedgerEntry."Amount to Apply";                    end;                until VendorLedgerEntry.Next() = 0;                TempVendorLedgerEntry.DeleteAll();                if (GenJnlLine."Bal. Account Type" = GenJnlLine."Bal. Account Type"::Customer) or (GenJnlLine."Bal. Account Type" = GenJnlLine."Bal. Account Type"::Vendor) then                    GenJnlLine.Amount := -GenJnlLine.Amount;                OnApplyVendorLedgerEntryAPIOnBeforeValidateAmount(GenJnlLine);                GenJnlLine.Validate(Amount);            end else                repeat                    OnApplyVendorLedgerEntryAPIOnBeforeCheckAgainstApplnCurrencyAmountNonZero(GenJnlLine, VendorLedgerEntry);                    CheckAgainstApplnCurrency(CurrencyCode2, VendorLedgerEntry."Currency Code", AccType::Vendor, true);                until VendorLedgerEntry.Next() = 0;            if GenJnlLine."Currency Code" <> CurrencyCode2 then                if GenJnlLine.Amount = 0 then                    GenJnlLine."Currency Code" := VendorLedgerEntry."Currency Code"                else begin                    OnApplyVendorLedgerEntryAPIOnBeforeCheckAgainstApplnCurrencyDifferentCurrenciesAmountNonZero(GenJnlLine, VendorLedgerEntry);                    CheckAgainstApplnCurrency(GenJnlLine."Currency Code", VendorLedgerEntry."Currency Code", AccType::Vendor, true);                end;            GenJnlLine."Applies-to Doc. Type" := GenJnlLine."Applies-to Doc. Type"::" ";            GenJnlLine."Applies-to Doc. No." := '';            OnApplyVendorLedgerEntryOnAfterSetVendorAppliesToDocNo(GenJnlLine, VendorLedgerEntry);        end else            GenJnlLine."Applies-to ID" := '';        GenJnlLine.SetJournalLineFieldsFromApplication();        if GenJnlLine.Modify() then;        if GenJnlLine.Amount <> 0 then            if not PaymentToleranceMgt.PmtTolGenJnl(GenJnlLine) then                exit;    end;    local procedure ApplyVendorLedgerEntry(var GenJnlLine: Record "Gen. Journal Line")    var        VendLedgEntry: Record "Vendor Ledger Entry";        TempVendorLedgerEntry: Record "Vendor Ledger Entry" temporary;        CustomAppliesToId: Code[50];        IsHandled: Boolean;    begin        GetAppliedVendorEntries(TempVendorLedgerEntry, GenJnlLine);        EntrySelected := SelectVendLedgEntry(GenJnlLine, CustomAppliesToId);        if not EntrySelected then            exit;        VendLedgEntry.Reset();        VendLedgEntry.SetCurrentKey("Vendor No.", Open, Positive);        VendLedgEntry.SetRange("Vendor No.", AccNo);        VendLedgEntry.SetRange(Open, true);        VendLedgEntry.SetRange("Applies-to ID", GenJnlLine."Applies-to ID");        OnAfterVendLedgEntrySetFilters(VendLedgEntry, GenJnlLine, AccNo);        if VendLedgEntry.Find('-') then begin            CurrencyCode2 := VendLedgEntry."Currency Code";            if GenJnlLine.Amount = 0 then begin                repeat                    if not TempVendorLedgerEntry.Get(VendLedgEntry."Entry No.") then begin                        PaymentToleranceMgt.DelPmtTolApllnDocNo(GenJnlLine, VendLedgEntry."Document No.");                        OnApplyVendorLedgerEntryOnBeforeCheckAgainstApplnCurrency(GenJnlLine, VendLedgEntry);                        CheckAgainstApplnCurrency(CurrencyCode2, VendLedgEntry."Currency Code", AccType::Vendor, true);                        UpdateVendLedgEntry(VendLedgEntry);                        IsHandled := false;                        OnBeforeFindVendApply(GenJnlLine, VendLedgEntry, GenJnlLine.Amount, IsHandled);                        if not IsHandled then                            if PaymentToleranceMgt.CheckCalcPmtDiscGenJnlVend(GenJnlLine, VendLedgEntry, 0, false) and                               (Abs(VendLedgEntry."Amount to Apply") >=                                Abs(VendLedgEntry."Remaining Amount" - VendLedgEntry.GetRemainingPmtDiscPossible(GenJnlLine."Posting Date")))                            then                                GenJnlLine.Amount := GenJnlLine.Amount - (VendLedgEntry."Amount to Apply" - VendLedgEntry.GetRemainingPmtDiscPossible(GenJnlLine."Posting Date"))                            else                                GenJnlLine.Amount := GenJnlLine.Amount - VendLedgEntry."Amount to Apply";                        GenJnlLine."Remit-to Code" := VendLedgEntry."Remit-to Code";                    end;                until VendLedgEntry.Next() = 0;                TempVendorLedgerEntry.DeleteAll();                if (GenJnlLine."Bal. Account Type" = GenJnlLine."Bal. Account Type"::Customer) or (GenJnlLine."Bal. Account Type" = GenJnlLine."Bal. Account Type"::Vendor) then                    GenJnlLine.Amount := -GenJnlLine.Amount;                OnApplyVendorLedgerEntryOnBeforeValidateAmount(GenJnlLine, VendLedgEntry);                GenJnlLine.Validate(Amount);            end else                repeat                    OnApplyVendorLedgerEntryOnBeforeCheckAgainstApplnCurrencyAmountNotZero(GenJnlLine, VendLedgEntry);                    CheckAgainstApplnCurrency(CurrencyCode2, VendLedgEntry."Currency Code", AccType::Vendor, true);                until VendLedgEntry.Next() = 0;            if GenJnlLine."Currency Code" <> CurrencyCode2 then                if GenJnlLine.Amount = 0 then begin                    IsHandled := false;                    OnApplyVendorLedgerEntryOnBeforeConfirmUpdateCurrency(GenJnlLine, VendLedgEntry."Currency Code", IsHandled);                    if not IsHandled then begin                        ConfirmCurrencyUpdate(GenJnlLine, VendLedgEntry."Currency Code");                        GenJnlLine."Currency Code" := VendLedgEntry."Currency Code";                    end;                end else begin                    OnApplyVendorLedgerEntryOnBeforeCheckAgainstApplnCurrencyDifferentCurrenciesAmountNotZero(GenJnlLine, VendLedgEntry);                    CheckAgainstApplnCurrency(GenJnlLine."Currency Code", VendLedgEntry."Currency Code", AccType::Vendor, true);                end;            GenJnlLine."Applies-to Doc. Type" := GenJnlLine."Applies-to Doc. Type"::" ";            GenJnlLine."Applies-to Doc. No." := '';            OnApplyVendorLedgerEntryOnAfterSetGenJnlLineAppliesToDocNo(GenJnlLine, VendLedgEntry);        end else            GenJnlLine."Applies-to ID" := '';        if (GenJnlLine."Applies-to ID" = '') and (CustomAppliesToId <> '') then            GenJnlLine."Applies-to ID" := CustomAppliesToId;        GenJnlLine.SetJournalLineFieldsFromApplication();        OnApplyVendorLedgerEntryOnBeforeModify(GenJnlLine, TempVendorLedgerEntry, VendLedgEntry);        if GenJnlLine.Modify() then;        if GenJnlLine.Amount <> 0 then            if not PaymentToleranceMgt.PmtTolGenJnl(GenJnlLine) then                exit;    end;    local procedure ApplyEmployeeLedgerEntry(var GenJnlLine: Record "Gen. Journal Line")    var        EmplLedgEntry: Record "Employee Ledger Entry";        CustomAppliesToId: Code[50];    begin        EntrySelected := SelectEmplLedgEntry(GenJnlLine, CustomAppliesToId);        if not EntrySelected then            exit;        EmplLedgEntry.Reset();        EmplLedgEntry.SetCurrentKey("Employee No.", Open, Positive);        EmplLedgEntry.SetRange("Employee No.", AccNo);        EmplLedgEntry.SetRange(Open, true);        EmplLedgEntry.SetRange("Applies-to ID", GenJnlLine."Applies-to ID");        if EmplLedgEntry.Find('-') then begin            CurrencyCode2 := EmplLedgEntry."Currency Code";            if GenJnlLine.Amount = 0 then begin                repeat                    UpdateEmployeeLedgEntry(EmplLedgEntry);                    OnApplyEmployeeLedgerEntryOnBeforeUpdateAmount(GenJnlLine, EmplLedgEntry);                    GenJnlLine.Amount := GenJnlLine.Amount - EmplLedgEntry."Amount to Apply";                until EmplLedgEntry.Next() = 0;                if (GenJnlLine."Bal. Account Type" = GenJnlLine."Bal. Account Type"::Customer) or                   (GenJnlLine."Bal. Account Type" = GenJnlLine."Bal. Account Type"::Vendor) or                   (GenJnlLine."Bal. Account Type" = GenJnlLine."Bal. Account Type"::Employee)                then                    GenJnlLine.Amount := -GenJnlLine.Amount;                GenJnlLine.Validate(Amount);            end;            if GenJnlLine."Currency Code" <> CurrencyCode2 then                if GenJnlLine.Amount = 0 then begin                    ConfirmCurrencyUpdate(GenJnlLine, EmplLedgEntry."Currency Code");                    GenJnlLine."Currency Code" := EmplLedgEntry."Currency Code"                end;            GenJnlLine."Applies-to Doc. Type" := GenJnlLine."Applies-to Doc. Type"::" ";            GenJnlLine."Applies-to Doc. No." := '';        end else            GenJnlLine."Applies-to ID" := '';        if (GenJnlLine."Applies-to ID" = '') and (CustomAppliesToId <> '') then            GenJnlLine."Applies-to ID" := CustomAppliesToId;        GenJnlLine.SetJournalLineFieldsFromApplication();        if GenJnlLine.Modify() then;        OnAfterApplyEmployeeLedgerEntry(GenJnlLine, EmplLedgEntry);    end;    local procedure GetAppliedCustomerEntries(var TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary; GenJournalLineSource: Record "Gen. Journal Line")    var        GenJournalLine: Record "Gen. Journal Line";        CustLedgerEntry: Record "Cust. Ledger Entry";    begin        if GenJournalLineSource.Amount <> 0 then            exit;        GenJournalLine.SetRange("Journal Template Name", GenJournalLineSource."Journal Template Name");        GenJournalLine.SetRange("Journal Batch Name", GenJournalLineSource."Journal Batch Name");        GenJournalLine.SetFilter("Line No.", '<>%1', GenJournalLineSource."Line No.");        GenJournalLine.SetRange("Document No.", GenJournalLineSource."Document No.");        if not GenJournalLine.IsEmpty() then begin            CustLedgerEntry.SetCurrentKey("Customer No.", Open, Positive);            CustLedgerEntry.SetRange("Customer No.", AccNo);            CustLedgerEntry.SetRange(Open, true);            CustLedgerEntry.SetRange("Applies-to ID", GenJournalLineSource."Document No.");            if CustLedgerEntry.FindSet() then                repeat                    TempCustLedgerEntry := CustLedgerEntry;                    TempCustLedgerEntry.Insert();                until CustLedgerEntry.Next() = 0;        end;    end;    local procedure GetAppliedVendorEntries(var TempVendorLedgerEntry: Record "Vendor Ledger Entry" temporary; GenJournalLineSource: Record "Gen. Journal Line")    var        GenJournalLine: Record "Gen. Journal Line";        VendorLedgerEntry: Record "Vendor Ledger Entry";    begin        if GenJournalLineSource.Amount <> 0 then            exit;        GenJournalLine.SetRange("Journal Template Name", GenJournalLineSource."Journal Template Name");        GenJournalLine.SetRange("Journal Batch Name", GenJournalLineSource."Journal Batch Name");        GenJournalLine.SetFilter("Line No.", '<>%1', GenJournalLineSource."Line No.");        GenJournalLine.SetRange("Document No.", GenJournalLineSource."Document No.");        if not GenJournalLine.IsEmpty() then begin            VendorLedgerEntry.SetCurrentKey("Vendor No.", Open, Positive);            VendorLedgerEntry.SetRange("Vendor No.", AccNo);            VendorLedgerEntry.SetRange(Open, true);            VendorLedgerEntry.SetRange("Applies-to ID", GenJournalLineSource."Document No.");            if VendorLedgerEntry.FindSet() then                repeat                    TempVendorLedgerEntry := VendorLedgerEntry;                    TempVendorLedgerEntry.Insert();                until VendorLedgerEntry.Next() = 0;        end;    end;    local procedure ConfirmCurrencyUpdate(GenJournalLine: Record "Gen. Journal Line"; CurrencyCode: Code[10])    var        ConfirmManagement: Codeunit "Confirm Management";    begin        if not ConfirmManagement.GetResponseOrDefault(             StrSubstNo(               ConfirmChangeQst, GenJournalLine.TableCaption(), GenJournalLine."Currency Code",               CurrencyCode), true)        then            Error(UpdateInterruptedErr);    end;    local procedure GetAppliedAmountOnCustLedgerEntry(CustLedgEntry: Record "Cust. Ledger Entry"; var AppliedAmount: Decimal)    var        CustLedgEntry2: Record "Cust. Ledger Entry";    begin        if CustLedgEntry."Amount to Apply" = 0 then            exit;        CustLedgEntry2.Get(CustLedgEntry."Entry No.");        if CustLedgEntry2."Amount to Apply" = CustLedgEntry."Amount to Apply" then            CalcAppliedAmountOnCustLedgerEntry(CustLedgEntry, AppliedAmount)        else            CalcAppliedAmountOnCustLedgerEntry(CustLedgEntry2, AppliedAmount);    end;    local procedure CalcAppliedAmountOnCustLedgerEntry(CustLedgEntry: Record "Cust. Ledger Entry"; var AppliedAmount: Decimal)    begin        CustLedgEntry.CalcFields("Remaining Amount");        OnCalcAppliedAmountOnCustLedgerEntryOnAfterCalcRemainingAmount(CustLedgEntry);        if PaymentToleranceMgt.CheckCalcPmtDiscGenJnlCust(GenJnlLine, CustLedgEntry, 0, false) and            (Abs(CustLedgEntry."Amount to Apply") >=            Abs(CustLedgEntry."Remaining Amount" - CustLedgEntry."Remaining Pmt. Disc. Possible"))        then            AppliedAmount := AppliedAmount - (CustLedgEntry."Amount to Apply" - CustLedgEntry."Remaining Pmt. Disc. Possible")        else            AppliedAmount := AppliedAmount - CustLedgEntry."Amount to Apply";    end;    [Scope('OnPrem')]    procedure GetEntrySelected(): Boolean    begin        exit(EntrySelected);    end;    /// <summary>    /// Integration event raised after the application process completes.    /// Enables custom post-processing logic after general journal line application.    /// </summary>    /// <param name="GenJnlLine">General journal line that was processed for application</param>    [IntegrationEvent(false, false)]    local procedure OnAfterRun(var GenJnlLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Integration event raised after setting filters on customer ledger entries during application selection.    /// Enables custom filtering logic for customer entry selection processes.    /// </summary>    /// <param name="CustLedgerEntry">Customer ledger entry with applied filters</param>    /// <param name="GenJournalLine">General journal line context for application</param>    /// <param name="AccNo">Account number for filtering</param>    /// <param name="CustomAppliesToId">Custom application ID for filtering</param>    /// <param name="IsHandled">Set to true to skip standard processing</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCustLedgEntrySetFilters(var CustLedgerEntry: Record "Cust. Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line"; AccNo: Code[20]; var CustomAppliesToId: Code[50]; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised after setting filters on vendor ledger entries during application selection.    /// Enables custom filtering logic for vendor entry selection processes.    /// </summary>    /// <param name="VendorLedgerEntry">Vendor ledger entry with applied filters</param>    /// <param name="GenJournalLine">General journal line context for application</param>    /// <param name="AccNo">Account number for filtering</param>    [IntegrationEvent(false, false)]    local procedure OnAfterVendLedgEntrySetFilters(var VendorLedgerEntry: Record "Vendor Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; AccNo: Code[20])    begin    end;    /// <summary>    /// Integration event raised after applying employee ledger entry with general journal line.    /// Enables custom post-processing logic for employee payment applications.    /// </summary>    /// <param name="GenJournalLine">General journal line used for application</param>    /// <param name="EmployeeLedgerEntry">Employee ledger entry that was applied</param>    [IntegrationEvent(false, false)]    local procedure OnAfterApplyEmployeeLedgerEntry(var GenJournalLine: Record "Gen. Journal Line"; EmployeeLedgerEntry: Record "Employee Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised after selecting a customer ledger entry for application.    /// Enables customization of the customer selection process and additional validation.    /// </summary>    /// <param name="GenJournalLine">General journal line being processed</param>    /// <param name="AccNo">Customer account number selected</param>    /// <param name="Selected">Boolean indicating if selection was successful</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSelectCustLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var AccNo: Code[20]; var Selected: Boolean)    begin    end;    /// <summary>    /// Integration event raised after selecting an employee ledger entry for application.    /// Enables customization of the employee selection process and additional validation.    /// </summary>    /// <param name="GenJournalLine">General journal line being processed</param>    /// <param name="AccNo">Employee account number selected</param>    /// <param name="Selected">Boolean indicating if selection was successful</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSelectEmplLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var AccNo: Code[20]; var Selected: Boolean)    begin    end;    /// <summary>    /// Integration event raised after selecting a vendor ledger entry for application.    /// Enables customization of the vendor selection process and additional validation.    /// </summary>    /// <param name="GenJournalLine">General journal line being processed</param>    /// <param name="AccNo">Vendor account number selected</param>    /// <param name="Selected">Boolean indicating if selection was successful</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSelectVendLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var AccNo: Code[20]; var Selected: Boolean)    begin    end;    /// <summary>    /// Integration event raised before checking application currency for customer ledger entries.    /// Enables custom currency validation logic for customer applications.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="CustLedgerEntry">Customer ledger entry being applied to</param>    [IntegrationEvent(false, false)]    local procedure OnApplyCustomerLedgerEntryOnBeforeCheckAgainstApplnCurrency(var GenJournalLine: Record "Gen. Journal Line"; CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before modifying a customer ledger entry during application.    /// Enables custom field updates and validation before the ledger entry is modified.    /// </summary>    /// <param name="GenJnlLine">General journal line being applied</param>    /// <param name="CustLedgerEntry">Customer ledger entry being modified</param>    [IntegrationEvent(false, false)]    local procedure OnApplyCustomerLedgerEntryOnBeforeModify(var GenJnlLine: Record "Gen. Journal Line"; CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before checking application currency for vendor ledger entries.    /// Enables custom currency validation logic for vendor applications.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry being applied to</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryOnBeforeCheckAgainstApplnCurrency(var GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before modifying a vendor ledger entry during application.    /// Enables custom field updates and validation before the ledger entry is modified.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry being modified</param>    /// <param name="VendorLedgerEntryLocal">Local copy of vendor ledger entry for comparison</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryOnBeforeModify(var GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry"; VendorLedgerEntryLocal: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before updating amount for employee ledger entry applications.    /// Enables custom amount calculation logic for employee transactions.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="EmployeeLedgerEntry">Employee ledger entry being processed</param>    [IntegrationEvent(false, false)]    local procedure OnApplyEmployeeLedgerEntryOnBeforeUpdateAmount(var GenJournalLine: Record "Gen. Journal Line"; EmployeeLedgerEntry: Record "Employee Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before starting the general journal application process.    /// Enables custom preprocessing logic and allows complete replacement of standard application logic.    /// </summary>    /// <param name="GenJnlLine">General journal line to be processed for application</param>    /// <param name="IsHandled">Set to true to skip standard application processing</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeRun(var GenJnlLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before checking currency compatibility during application.    /// Enables custom currency validation logic and currency code modification.    /// </summary>    /// <param name="ApplnCurrencyCode">Application currency code to validate</param>    /// <param name="CompareCurrencyCode">Comparison currency code for validation</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckAgainstApplnCurrency(var ApplnCurrencyCode: Code[10]; var CompareCurrencyCode: Code[10])    begin    end;    /// <summary>    /// Integration event raised before finding customer ledger entries for application.    /// Enables custom application logic and amount calculation for customer entries.    /// </summary>    /// <param name="GenJournalLine">General journal line to apply</param>    /// <param name="CustLedgerEntry">Customer ledger entry being evaluated</param>    /// <param name="Amount">Amount to apply (by reference)</param>    /// <param name="IsHandled">Set to true to skip standard application logic</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeFindCustApply(GenJournalLine: Record "Gen. Journal Line"; CustLedgerEntry: Record "Cust. Ledger Entry"; var Amount: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before finding vendor ledger entries for application.    /// Enables custom application logic and amount calculation for vendor entries.    /// </summary>    /// <param name="GenJournalLine">General journal line to apply</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry being evaluated</param>    /// <param name="Amount">Amount to apply (by reference)</param>    /// <param name="IsHandled">Set to true to skip standard application logic</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeFindVendApply(GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry"; var Amount: Decimal; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before selecting customer ledger entries for application.    /// Enables custom selection logic and filtering for customer applications.    /// </summary>    /// <param name="GenJournalLine">General journal line being processed</param>    /// <param name="AccNo">Customer account number (by reference)</param>    /// <param name="Selected">Selection result (by reference)</param>    /// <param name="IsHandled">Set to true to skip standard selection logic</param>    /// <param name="CustomAppliesToId">Custom application ID for filtering</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSelectCustLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var AccNo: Code[20]; var Selected: Boolean; var IsHandled: Boolean; var CustomAppliesToId: Code[50])    begin    end;    /// <summary>    /// Integration event raised before selecting employee ledger entries for application.    /// Enables custom selection logic and filtering for employee applications.    /// </summary>    /// <param name="GenJournalLine">General journal line being processed</param>    /// <param name="AccNo">Employee account number (by reference)</param>    /// <param name="Selected">Selection result (by reference)</param>    /// <param name="IsHandled">Set to true to skip standard selection logic</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSelectEmplLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var AccNo: Code[20]; var Selected: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before selecting vendor ledger entries for application.    /// Enables custom selection logic and filtering for vendor applications.    /// </summary>    /// <param name="GenJournalLine">General journal line being processed</param>    /// <param name="AccNo">Vendor account number (by reference)</param>    /// <param name="Selected">Selection result (by reference)</param>    /// <param name="IsHandled">Set to true to skip standard selection logic</param>    /// <param name="CustomAppliesToId">Custom application ID for filtering</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSelectVendLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var AccNo: Code[20]; var Selected: Boolean; var IsHandled: Boolean; var CustomAppliesToId: Code[50])    begin    end;    /// <summary>    /// Integration event raised after setting filters for customer ledger entry selection.    /// Enables custom filtering and additional selection criteria for customer entries.    /// </summary>    /// <param name="CustLedgerEntry">Customer ledger entry record with filters applied</param>    /// <param name="GenJournalLine">General journal line driving the selection</param>    [IntegrationEvent(false, false)]    local procedure OnSelectCustLedgEntryOnAfterSetFilters(var CustLedgerEntry: Record "Cust. Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Integration event raised after setting filters for employee ledger entry selection.    /// Enables custom filtering and additional selection criteria for employee entries.    /// </summary>    /// <param name="EmployeeLedgerEntry">Employee ledger entry record with filters applied</param>    /// <param name="GenJournalLine">General journal line driving the selection</param>    [IntegrationEvent(false, false)]    local procedure OnSelectEmplLedgEntryOnAfterSetFilters(var EmployeeLedgerEntry: Record "Employee Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Integration event raised after setting filters for vendor ledger entry selection.    /// Enables custom filtering and additional selection criteria for vendor entries.    /// </summary>    /// <param name="VendorLedgerEntry">Vendor ledger entry record with filters applied</param>    /// <param name="GenJournalLine">General journal line driving the selection</param>    [IntegrationEvent(false, false)]    local procedure OnSelectVendLedgEntryOnAfterSetFilters(var VendorLedgerEntry: Record "Vendor Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Integration event raised before confirming currency update for vendor applications.    /// Enables custom confirmation logic and currency update handling.    /// </summary>    /// <param name="GenJournalLine">General journal line being processed</param>    /// <param name="CurrencyCode">Currency code requiring confirmation</param>    /// <param name="IsHandled">Set to true to skip standard confirmation dialog</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryOnBeforeConfirmUpdateCurrency(var GenJournalLine: Record "Gen. Journal Line"; CurrencyCode: Code[10]; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before confirming currency update for customer applications.    /// Enables custom confirmation logic and currency update handling.    /// </summary>    /// <param name="GenJournalLine">General journal line being processed</param>    /// <param name="CurrencyCode">Currency code requiring confirmation</param>    /// <param name="IsHandled">Set to true to skip standard confirmation dialog</param>    [IntegrationEvent(false, false)]    local procedure OnApplyCustomerLedgerEntryOnBeforeConfirmUpdateCurrency(var GenJournalLine: Record "Gen. Journal Line"; CurrencyCode: Code[10]; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before checking application currency when customer amount is not zero.    /// Enables custom currency validation for non-zero customer application amounts.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="CustLedgerEntry">Customer ledger entry with non-zero amount</param>    [IntegrationEvent(false, false)]    local procedure OnApplyCustomerLedgerEntryOnBeforeCheckAgainstApplnCurrencyCustomerAmountNotZero(GenJournalLine: Record "Gen. Journal Line"; CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before checking application currency for customer applications.    /// Enables custom currency validation logic for customer ledger entries.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="CustLedgerEntry">Customer ledger entry being checked</param>    [IntegrationEvent(false, false)]    local procedure OnApplyCustomerLedgerEntryOnBeforeCheckAgainstApplnCurrencyCustomer(GenJournalLine: Record "Gen. Journal Line"; CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised after validating amount in customer ledger entry application.    /// Enables custom processing after amount validation is complete.    /// </summary>    /// <param name="GenJnlLine">General journal line with validated amount</param>    /// <param name="CustLedgEntry">Customer ledger entry being applied</param>    [IntegrationEvent(true, false)]    local procedure OnApplyCustomerLedgerEntryOnAfterValidateAmount(var GenJnlLine: Record "Gen. Journal Line"; var CustLedgEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before checking application currency in vendor API operations.    /// Enables custom currency validation for vendor applications via API.    /// </summary>    /// <param name="GenJournalLine">General journal line being processed</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry being applied via API</param>    [IntegrationEvent(false, false)]    local procedure OnSetVendApplIdAPIOnBeforeCheckAgainstApplnCurrency(GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before checking application currency when vendor API amount is zero.    /// Enables custom currency validation for zero-amount vendor applications via API.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry with zero amount</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryAPIOnBeforeCheckAgainstApplnCurrencyAmountZero(GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before checking application currency when vendor API amount is non-zero.    /// Enables custom currency validation for non-zero vendor applications via API.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry with non-zero amount</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryAPIOnBeforeCheckAgainstApplnCurrencyAmountNonZero(GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before checking application currency for different currencies with non-zero vendor API amounts.    /// Enables custom currency validation when vendor API applications involve different currencies.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry with different currency</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryAPIOnBeforeCheckAgainstApplnCurrencyDifferentCurrenciesAmountNonZero(GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised after setting applies-to document number for vendor applications.    /// Enables custom processing after vendor application document linking is established.    /// </summary>    /// <param name="GenJournalLine">General journal line with updated applies-to document number</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry being applied</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryOnAfterSetGenJnlLineAppliesToDocNo(var GenJournalLine: Record "Gen. Journal Line"; var VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before checking application currency when vendor amount is not zero.    /// Enables custom currency validation for non-zero vendor application amounts.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry with non-zero amount</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryOnBeforeCheckAgainstApplnCurrencyAmountNotZero(GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before checking application currency for different currencies with non-zero vendor amounts.    /// Enables custom currency validation when vendor applications involve different currencies and non-zero amounts.    /// </summary>    /// <param name="GenJournalLine">General journal line being applied</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry with different currency and non-zero amount</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryOnBeforeCheckAgainstApplnCurrencyDifferentCurrenciesAmountNotZero(GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised after setting applies-to document number for customer applications.    /// Enables custom processing after customer application document linking is established.    /// </summary>    /// <param name="GenJournalLine">General journal line with updated applies-to document number</param>    /// <param name="CustLedgerEntry">Customer ledger entry being applied</param>    [IntegrationEvent(false, false)]    local procedure OnApplyCustomerLedgerEntryOnAfterSetCustomerAppliesToDocNo(var GenJournalLine: Record "Gen. Journal Line"; var CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised after setting applies-to document number for vendor applications.    /// Enables custom processing after vendor application document linking is established.    /// </summary>    /// <param name="GenJournalLine">General journal line with updated applies-to document number</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry being applied</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryOnAfterSetVendorAppliesToDocNo(var GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before updating customer ledger entries during application.    /// Enables custom update logic and validation before customer ledger entry modification.    /// </summary>    /// <param name="CustLedgerEntry">Customer ledger entry being updated</param>    /// <param name="GenJournalLine">General journal line driving the update</param>    /// <param name="IsHandled">Set to true to skip standard update logic</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateCustLedgEntry(var CustLedgerEntry: Record "Cust. Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before updating vendor ledger entries during application.    /// Enables custom update logic and validation before vendor ledger entry modification.    /// </summary>    /// <param name="VendorLedgerEntry">Vendor ledger entry being updated</param>    /// <param name="GenJournalLine">General journal line driving the update</param>    /// <param name="IsHandled">Set to true to skip standard update logic</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateVendLedgEntry(var VendorLedgerEntry: Record "Vendor Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised after updating vendor ledger entries during application.    /// Enables custom processing after vendor ledger entry modification is complete.    /// </summary>    /// <param name="GenJournalLine">General journal line that drove the update</param>    /// <param name="VendorLedgerEntry">Vendor ledger entry that was updated</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateVendLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before validating amount in vendor API applications.    /// Enables custom amount validation logic for vendor applications via API.    /// </summary>    /// <param name="GenJournalLine">General journal line being validated</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryAPIOnBeforeValidateAmount(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Integration event raised before validating amount in vendor applications.    /// Enables custom amount validation logic for standard vendor ledger entry applications.    /// </summary>    /// <param name="GenJournalLine">General journal line being validated</param>    /// <param name="VendorLedgEntry">Vendor ledger entry being applied</param>    [IntegrationEvent(false, false)]    local procedure OnApplyVendorLedgerEntryOnBeforeValidateAmount(var GenJournalLine: Record "Gen. Journal Line"; var VendorLedgEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised before checking posting date in vendor API applications.    /// Enables custom posting date validation for vendor applications via API.    /// </summary>    /// <param name="TempApplyingVendorLedgerEntry">Temporary vendor ledger entry being applied</param>    /// <param name="GenJournalLine">General journal line driving the application</param>    /// <param name="VendorLedgerEntry">Target vendor ledger entry for application</param>    [IntegrationEvent(false, false)]    local procedure OnSetVendApplIdAPIOnBeforeCheckPostingDate(var TempApplyingVendorLedgerEntry: Record "Vendor Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line"; var VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    /// <summary>    /// Integration event raised after calculating remaining amount in customer ledger entry applied amount calculation.    /// Enables custom processing after remaining amount calculation is complete.    /// </summary>    /// <param name="CustLedgerEntry">Customer ledger entry with calculated remaining amount</param>    [IntegrationEvent(false, false)]    local procedure OnCalcAppliedAmountOnCustLedgerEntryOnAfterCalcRemainingAmount(var CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;}