Codeunit 225 Gen. Jnl.-Apply
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;}