Table 179 Reversal Entry, source in 29
Source29
src/Layers/W1/BaseApp/Finance/GeneralLedger/Reversal/ReversalEntry.Table.al2565 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.GeneralLedger.Reversal;
using Microsoft.Bank.BankAccount;
using Microsoft.Bank.Check;
using Microsoft.Bank.Ledger;
using Microsoft.Bank.Statement;
using Microsoft.Finance.Currency;
using Microsoft.Finance.GeneralLedger.Account;
using Microsoft.Finance.GeneralLedger.Journal;
using Microsoft.Finance.GeneralLedger.Ledger;
using Microsoft.Finance.GeneralLedger.Setup;
using Microsoft.Finance.VAT.Ledger;
using Microsoft.FixedAssets.Depreciation;
using Microsoft.FixedAssets.FixedAsset;
using Microsoft.FixedAssets.Ledger;
using Microsoft.FixedAssets.Maintenance;
using Microsoft.FixedAssets.Posting;
using Microsoft.FixedAssets.Setup;
using Microsoft.Foundation.AuditCodes;
using Microsoft.Foundation.Period;
using Microsoft.HumanResources.Employee;
using Microsoft.HumanResources.Payables;
using Microsoft.Purchases.Payables;
using Microsoft.Purchases.Vendor;
using Microsoft.Sales.Customer;
using Microsoft.Sales.Receivables;
using System.Security.User;
using System.Utilities;
/// <summary>
/// Stores temporary information about ledger entries selected for reversal operations.
/// Provides comprehensive reversal functionality with entry validation and reversal processing workflow.
/// </summary>
/// <remarks>
/// Central table for managing reversal entries across all ledger types including G/L, customer, vendor, employee, bank account, Fixed Asset, maintenance, and VAT.
/// Supports both register-based and transaction-based reversal modes with comprehensive validation and audit trail maintenance.
/// Integrates with all posting engines and maintains referential integrity during reversal operations.
/// </remarks>
table 179 "Reversal Entry"
{
Caption = 'Reversal Entry';
PasteIsValid = false;
DataClassification = CustomerContent;
fields
{
/// <summary>
/// Sequential line number for ordering reversal entries within the reversal operation.
/// </summary>
field(1; "Line No."; Integer)
{
Caption = 'Line No.';
}
/// <summary>
/// Specifies the type of ledger entry being reversed (G/L Account, Customer, Vendor, Employee, Bank Account, Fixed Asset, Maintenance, VAT).
/// </summary>
field(2; "Entry Type"; Enum "Reversal Entry Type")
{
Caption = 'Entry Type';
}
/// <summary>
/// Entry number of the original ledger entry being reversed, with table relation based on Entry Type.
/// </summary>
field(3; "Entry No."; Integer)
{
Caption = 'Entry No.';
ToolTip = 'Specifies the entry number of the original ledger entry that is being reversed.';
TableRelation = if ("Entry Type" = const("G/L Account")) "G/L Entry"
else
if ("Entry Type" = const(Customer)) "Cust. Ledger Entry"
else
if ("Entry Type" = const(Vendor)) "Vendor Ledger Entry"
else
if ("Entry Type" = const("Bank Account")) "Bank Account Ledger Entry"
else
if ("Entry Type" = const("Fixed Asset")) "FA Ledger Entry"
else
if ("Entry Type" = const(Maintenance)) "Maintenance Ledger Entry"
else
if ("Entry Type" = const(VAT)) "VAT Entry"
else
if ("Entry Type" = const(Employee)) "Employee Ledger Entry";
}
/// <summary>
/// G/L Register number that contains the entry being reversed, used for register-based reversals.
/// </summary>
field(4; "G/L Register No."; Integer)
{
Caption = 'G/L Register No.';
ToolTip = 'Specifies the number of the general ledger register, where the general ledger entry in this record was posted.';
TableRelation = "G/L Register";
}
/// <summary>
/// Source code from the original entry identifying the posting journal or process that created the entry.
/// </summary>
field(5; "Source Code"; Code[10])
{
Caption = 'Source Code';
ToolTip = 'Specifies the source code that specifies where the entry was created.';
TableRelation = "Source Code";
}
/// <summary>
/// Journal batch name from the original entry used for posting validation and filtering.
/// </summary>
field(6; "Journal Batch Name"; Code[10])
{
Caption = 'Journal Batch Name';
ToolTip = 'Specifies the name of the journal batch, a personalized journal layout, that the entries were posted from.';
}
/// <summary>
/// Transaction number linking related entries within the same posting transaction.
/// </summary>
field(7; "Transaction No."; Integer)
{
Caption = 'Transaction No.';
ToolTip = 'Specifies the number of the transaction that was reversed.';
}
/// <summary>
/// Source type indicating the master table type for the source number (Customer, Vendor, Bank Account, Fixed Asset, Employee).
/// </summary>
field(8; "Source Type"; Enum "Gen. Journal Source Type")
{
Caption = 'Source Type';
ToolTip = 'Specifies the source type that applies to the source number that is shown in the Source No. field.';
}
/// <summary>
/// Source number referencing the specific master record based on Source Type, with table relation validation.
/// </summary>
field(9; "Source No."; Code[20])
{
Caption = 'Source No.';
ToolTip = 'Specifies where the entry originated.';
TableRelation = if ("Source Type" = const(Customer)) Customer
else
if ("Source Type" = const(Vendor)) Vendor
else
if ("Source Type" = const("Bank Account")) "Bank Account"
else
if ("Source Type" = const("Fixed Asset")) "Fixed Asset"
else
if ("Source Type" = const(Employee)) Employee;
}
/// <summary>
/// Currency code from the original entry, blank indicates local currency (LCY).
/// </summary>
field(10; "Currency Code"; Code[10])
{
Caption = 'Currency Code';
ToolTip = 'Specifies the currency code for the amount on the line.';
TableRelation = Currency;
}
/// <summary>
/// Entry description from the original entry providing context for the reversal operation.
/// </summary>
field(11; Description; Text[100])
{
Caption = 'Description';
ToolTip = 'Specifies a description of the record.';
}
/// <summary>
/// Entry amount in the original currency from the entry being reversed.
/// </summary>
field(12; Amount; Decimal)
{
AutoFormatExpression = Rec."Currency Code";
AutoFormatType = 1;
Caption = 'Amount';
ToolTip = 'Specifies the amount on the entry to be reversed.';
}
/// <summary>
/// Debit amount from the original entry, showing only positive amounts for debit transactions.
/// </summary>
field(13; "Debit Amount"; Decimal)
{
AutoFormatExpression = Rec."Currency Code";
AutoFormatType = 1;
Caption = 'Debit Amount';
ToolTip = 'Specifies the total of the ledger entries that represent debits.';
}
/// <summary>
/// Credit amount from the original entry, showing only positive amounts for credit transactions.
/// </summary>
field(14; "Credit Amount"; Decimal)
{
AutoFormatExpression = Rec."Currency Code";
AutoFormatType = 1;
Caption = 'Credit Amount';
ToolTip = 'Specifies the total of the ledger entries that represent credits.';
}
/// <summary>
/// Entry amount in local currency (LCY) from the original entry being reversed.
/// </summary>
field(15; "Amount (LCY)"; Decimal)
{
AutoFormatExpression = '';
AutoFormatType = 1;
Caption = 'Amount (LCY)';
}
/// <summary>
/// Debit amount in local currency (LCY), showing only positive amounts for debit transactions.
/// </summary>
field(16; "Debit Amount (LCY)"; Decimal)
{
AutoFormatExpression = '';
AutoFormatType = 1;
Caption = 'Debit Amount (LCY)';
}
/// <summary>
/// Credit amount in local currency (LCY), showing only positive amounts for credit transactions.
/// </summary>
field(17; "Credit Amount (LCY)"; Decimal)
{
AutoFormatExpression = '';
AutoFormatType = 1;
Caption = 'Credit Amount (LCY)';
}
/// <summary>
/// VAT amount from the original entry that will be reversed.
/// </summary>
field(18; "VAT Amount"; Decimal)
{
AutoFormatExpression = Rec."Currency Code";
AutoFormatType = 1;
Caption = 'VAT Amount';
ToolTip = 'Specifies the amount of VAT that is included in the total amount.';
}
/// <summary>
/// Posting date from the original entry when the transaction was recorded.
/// </summary>
field(19; "Posting Date"; Date)
{
Caption = 'Posting Date';
ToolTip = 'Specifies the posting date for the entry.';
}
/// <summary>
/// Document type from the original entry (Invoice, Credit Memo, Payment, etc.).
/// </summary>
field(20; "Document Type"; Enum "Gen. Journal Document Type")
{
Caption = 'Document Type';
ToolTip = 'Specifies the document type that the entry belongs to.';
}
/// <summary>
/// Document number from the original entry identifying the source document.
/// </summary>
field(21; "Document No."; Code[20])
{
Caption = 'Document No.';
ToolTip = 'Specifies the document number of the transaction that created the entry.';
}
/// <summary>
/// Account number from the original entry being reversed.
/// </summary>
field(22; "Account No."; Code[20])
{
Caption = 'Account No.';
ToolTip = 'Specifies the account number that the reversal was posted to.';
}
/// <summary>
/// Account name from the original entry for display and reference purposes.
/// </summary>
field(23; "Account Name"; Text[100])
{
Caption = 'Account Name';
ToolTip = 'Specifies erroneous postings that you want to undo by using the Reverse function.';
}
/// <summary>
/// Balance account type from the original entry specifying the type of balance account used.
/// </summary>
field(25; "Bal. Account Type"; Enum "Gen. Journal Account Type")
{
Caption = 'Bal. Account Type';
ToolTip = 'Specifies the type of account that a balancing entry is posted to, such as BANK for a cash account.';
}
/// <summary>
/// Balance account number from the original entry for paired account posting validation.
/// </summary>
field(26; "Bal. Account No."; Code[20])
{
Caption = 'Bal. Account No.';
ToolTip = 'Specifies the number of the general ledger, customer, vendor, or bank account that the balancing entry is posted to, such as a cash account for cash purchases.';
TableRelation = if ("Bal. Account Type" = const("G/L Account")) "G/L Account"
else
if ("Bal. Account Type" = const(Customer)) Customer
else
if ("Bal. Account Type" = const(Vendor)) Vendor
else
if ("Bal. Account Type" = const("Bank Account")) "Bank Account"
else
if ("Bal. Account Type" = const("Fixed Asset")) "Fixed Asset";
}
/// <summary>
/// Fixed Asset posting category from the original entry for FA-related reversal validation.
/// </summary>
field(27; "FA Posting Category"; Enum "FA Ledger Posting Category")
{
AccessByPermission = TableData "Fixed Asset" = R;
Caption = 'FA Posting Category';
ToolTip = 'Specifies the posting category that is used for fixed assets.';
}
/// <summary>
/// Fixed Asset posting type from the original entry specifying the FA posting classification.
/// </summary>
field(28; "FA Posting Type"; Enum "Reversal Entry FA Posting Type")
{
AccessByPermission = TableData "Fixed Asset" = R;
Caption = 'FA Posting Type';
ToolTip = 'Specifies the posting type, if Account Type field contains Fixed Asset.';
}
/// <summary>
/// Type of reversal operation being performed (Transaction or Register-based reversal).
/// </summary>
field(30; "Reversal Type"; Option)
{
Caption = 'Reversal Type';
OptionCaption = 'Transaction,Register';
OptionMembers = Transaction,Register;
}
/// <summary>
/// Original amount in source currency before any currency conversion.
/// </summary>
field(31; "Source Currency Amount"; Decimal)
{
AutoFormatExpression = Rec."Source Currency Code";
AutoFormatType = 1;
Caption = 'Source Currency Amount';
DataClassification = CustomerContent;
}
/// <summary>
/// Original VAT amount in source currency before any currency conversion.
/// </summary>
field(32; "Source Currency VAT Amount"; Decimal)
{
AutoFormatExpression = Rec."Source Currency Code";
AutoFormatType = 1;
Caption = 'Source Currency VAT Amount';
DataClassification = CustomerContent;
}
field(33; "Source Currency Code"; Code[10])
{
Caption = 'Source Currency Code';
TableRelation = Currency;
DataClassification = CustomerContent;
}
}
keys
{
key(Key1; "Line No.")
{
Clustered = true;
}
key(Key2; "Entry Type")
{
}
key(Key3; "Document No.", "Posting Date", "Entry Type", "Entry No.")
{
}
key(Key4; "Entry Type", "Entry No.")
{
}
key(Key5; "Transaction No.")
{
}
}
fieldgroups
{
}
var
GlobalGLEntry: Record "G/L Entry";
GlobalCustLedgerEntry: Record "Cust. Ledger Entry";
GlobalVendorLedgerEntry: Record "Vendor Ledger Entry";
GlobalEmployeeLedgerEntry: Record "Employee Ledger Entry";
GlobalBankAccountLedgerEntry: Record "Bank Account Ledger Entry";
BankAccountStatement: Record "Bank Account Statement";
GlobalVATEntry: Record "VAT Entry";
GlobalFALedgerEntry: Record "FA Ledger Entry";
GlobalMaintenanceLedgerEntry: Record "Maintenance Ledger Entry";
GlobalGLRegister: Record "G/L Register";
GlobalFARegister: Record "FA Register";
GenJnlCheckLine: Codeunit "Gen. Jnl.-Check Line";
JnlTemplName: Code[10];
#pragma warning disable AA0074
#pragma warning disable AA0470
Text000: Label 'You cannot reverse %1 No. %2 because the entry is either applied to an entry or has been changed by a batch job.';
Text001: Label 'You cannot reverse %1 No. %2 because the posting date is not within the allowed posting period.';
#pragma warning restore AA0470
Text002: Label 'You cannot reverse the transaction because it is out of balance.';
#pragma warning disable AA0470
Text003: Label 'You cannot reverse %1 No. %2 because the entry has a related check ledger entry.';
#pragma warning restore AA0470
Text004: Label 'You can only reverse entries that were posted from a journal.';
#pragma warning disable AA0470
Text005: Label 'You cannot reverse %1 No. %2 because the %3 is not within the allowed posting period.';
Text006: Label 'You cannot reverse %1 No. %2 because the entry is closed.';
Text007: Label 'You cannot reverse %1 No. %2 because the entry is included in a bank account reconciliation line. The bank reconciliation has not yet been posted.';
Text008: Label 'You cannot reverse the transaction because the %1 has been sold.';
#pragma warning restore AA0470
#pragma warning restore AA0074
CannotReverseDeletedErr: Label 'The transaction cannot be reversed, because the %1 has been compressed or a %2 has been deleted.', Comment = '%1 and %2 = table captions';
#pragma warning disable AA0074
#pragma warning disable AA0470
Text010: Label 'You cannot reverse %1 No. %2 because the register has already been involved in a reversal.';
Text011: Label 'You cannot reverse %1 No. %2 because the entry has already been involved in a reversal.';
#pragma warning restore AA0470
#pragma warning restore AA0074
PostedAndAppliedSameTransactionErr: Label 'You cannot reverse register number %1 because it contains customer or vendor or employee ledger entries that have been posted and applied in the same transaction.\\You must reverse each transaction in register number %1 separately.', Comment = '%1="G/L Register No."';
CaptionTxt: Label '%1 %2 %3', Locked = true;
ReversalWithACYErr: Label 'Due to how Business Central posts and updates amounts in an additional reporting currency (ACY), you can''t use this feature if you use ACY. Business Central converts amounts in local currency to the alternate currency, but doesn''t net transactions. If you use ACY, you must manually reverse the amounts.';
protected var
GLSetup: Record "General Ledger Setup";
TempReversalEntry: Record "Reversal Entry" temporary;
AllowPostingFrom: Date;
AllowPostingto: Date;
HideDialog: Boolean;
HideWarningDialogs: Boolean;
MaxPostingDate: Date;
/// <summary>
/// Reverses all ledger entries from a specific transaction number.
/// </summary>
/// <param name="TransactionNo">Transaction number to reverse</param>
procedure ReverseTransaction(TransactionNo: Integer)
begin
ReverseEntries(TransactionNo, "Reversal Type"::Transaction);
end;
/// <summary>
/// Reverses all ledger entries from a specific G/L register number.
/// </summary>
/// <param name="RegisterNo">G/L register number to reverse</param>
procedure ReverseRegister(RegisterNo: Integer)
begin
CheckRegister(RegisterNo);
ReverseEntries(RegisterNo, "Reversal Type"::Register);
end;
local procedure ReverseEntries(Number: Integer; RevType: Option Transaction,Register)
var
ReversalPost: Codeunit "Reversal-Post";
ReverseTransactionEntries: Page "Reverse Transaction Entries";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeReverseEntries(Number, RevType, IsHandled, HideDialog, Rec, HideWarningDialogs);
if IsHandled then
exit;
InsertReversalEntry(Number, RevType);
OnReverseEntriesOnAfterInsertReversalEntry(TempReversalEntry, Number, RevType);
TempReversalEntry.SetCurrentKey("Document No.", "Posting Date", "Entry Type", "Entry No.");
if not HideDialog then begin
if (BankAccountStatement."Statement No." <> '') and (BankAccountStatement."Bank Account No." <> '') then
ReverseTransactionEntries.SetBankAccountStatement(BankAccountStatement);
ReverseTransactionEntries.SetReversalEntries(TempReversalEntry);
ReverseTransactionEntries.RunModal();
end
else begin
ReversalPost.SetPrint(false);
ReversalPost.SetHideDialog(HideWarningDialogs);
ReversalPost.Run(TempReversalEntry);
end;
TempReversalEntry.DeleteAll();
OnAfterReverseEntries(Number, RevType, HideDialog);
end;
protected procedure InsertReversalEntry(Number: Integer; RevType: Option Transaction,Register)
var
TempTransactionNoInteger: Record "Integer" temporary;
NextLineNo: Integer;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeInsertReversalEntry(Rec, Number, RevType, IsHandled);
if IsHandled then
exit;
GLSetup.Get();
TempReversalEntry.DeleteAll();
NextLineNo := 1;
TempTransactionNoInteger.Number := Number;
TempTransactionNoInteger.Insert();
SetReverseFilter(Number, RevType);
InsertFromCustLedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo);
InsertFromVendLedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo);
InsertFromEmplLedgerEntry(TempTransactionNoInteger, Number, RevType, NextLineNo);
InsertFromBankAccLedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo);
InsertFromFALedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo);
InsertFromMaintenanceLedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo);
InsertFromVATEntry(TempTransactionNoInteger, Number, RevType, NextLineNo);
InsertFromGLEntry(TempTransactionNoInteger, Number, RevType, NextLineNo);
OnAfterInsertReversalEntry(TempTransactionNoInteger, Number, RevType, NextLineNo, TempReversalEntry);
if TempReversalEntry.Find('-') then;
end;
/// <summary>
/// Validates all entries in the reversal list for reversal eligibility and business rule compliance.
/// </summary>
procedure CheckEntries()
var
GLAccount: Record "G/L Account";
DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry";
DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry";
DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry";
DateComprRegister: Record "Date Compr. Register";
BalanceCheckAmount: Decimal;
BalanceCheckAddCurrAmount: Decimal;
SkipCheck: Boolean;
begin
DetailedCustLedgEntry.LockTable();
DetailedVendorLedgEntry.LockTable();
DetailedEmployeeLedgerEntry.LockTable();
GlobalGLEntry.LockTable();
GlobalCustLedgerEntry.LockTable();
GlobalVendorLedgerEntry.LockTable();
GlobalEmployeeLedgerEntry.LockTable();
GlobalBankAccountLedgerEntry.LockTable();
GlobalFALedgerEntry.LockTable();
GlobalMaintenanceLedgerEntry.LockTable();
GlobalVATEntry.LockTable();
GlobalGLRegister.LockTable();
GlobalFARegister.LockTable();
GLSetup.Get();
MaxPostingDate := 0D;
SkipCheck := false;
OnBeforeCheckEntries(Rec, DATABASE::"G/L Entry", SkipCheck);
if not SkipCheck then begin
if GlobalGLEntry.IsEmpty() then
Error(CannotReverseDeletedErr, GlobalGLEntry.TableCaption(), GLAccount.TableCaption());
if GlobalGLEntry.Find('-') then begin
CheckGLEntry();
repeat
CheckGLAcc(GlobalGLEntry, BalanceCheckAmount, BalanceCheckAddCurrAmount);
until GlobalGLEntry.Next() = 0;
end;
if (BalanceCheckAmount <> 0) or (BalanceCheckAddCurrAmount <> 0) then
Error(Text002);
end;
if GlobalCustLedgerEntry.Find('-') then begin
SkipCheck := false;
OnBeforeCheckEntries(Rec, DATABASE::"Cust. Ledger Entry", SkipCheck);
if not SkipCheck then
repeat
CheckCust(GlobalCustLedgerEntry);
until GlobalCustLedgerEntry.Next() = 0;
end;
if GlobalVendorLedgerEntry.Find('-') then begin
SkipCheck := false;
OnBeforeCheckEntries(Rec, DATABASE::"Vendor Ledger Entry", SkipCheck);
if not SkipCheck then
repeat
CheckVend(GlobalVendorLedgerEntry);
until GlobalVendorLedgerEntry.Next() = 0;
end;
if GlobalEmployeeLedgerEntry.FindSet() then begin
SkipCheck := false;
OnBeforeCheckEntries(Rec, DATABASE::"Employee Ledger Entry", SkipCheck);
if not SkipCheck then
repeat
CheckEmpl(GlobalEmployeeLedgerEntry);
until GlobalEmployeeLedgerEntry.Next() = 0;
end;
if GlobalBankAccountLedgerEntry.Find('-') then begin
SkipCheck := false;
OnBeforeCheckEntries(Rec, DATABASE::"Bank Account Ledger Entry", SkipCheck);
if not SkipCheck then
repeat
CheckBankAcc(GlobalBankAccountLedgerEntry);
until GlobalBankAccountLedgerEntry.Next() = 0;
end;
if GlobalFALedgerEntry.Find('-') then begin
SkipCheck := false;
OnBeforeCheckEntries(Rec, DATABASE::"FA Ledger Entry", SkipCheck);
if not SkipCheck then
repeat
CheckFA(GlobalFALedgerEntry);
until GlobalFALedgerEntry.Next() = 0;
end;
if GlobalMaintenanceLedgerEntry.Find('-') then begin
SkipCheck := false;
OnBeforeCheckEntries(Rec, DATABASE::"Maintenance Ledger Entry", SkipCheck);
if not SkipCheck then
repeat
CheckMaintenance(GlobalMaintenanceLedgerEntry);
until GlobalMaintenanceLedgerEntry.Next() = 0;
end;
if GlobalVATEntry.Find('-') then begin
SkipCheck := false;
OnBeforeCheckEntries(Rec, DATABASE::"VAT Entry", SkipCheck);
if not SkipCheck then
repeat
CheckVAT(GlobalVATEntry);
until GlobalVATEntry.Next() = 0;
end;
OnAfterCheckEntries(MaxPostingDate, Rec);
DateComprRegister.CheckMaxDateCompressed(MaxPostingDate, 1);
end;
local procedure CheckGLEntry()
var
SourceCodeSetup: Record "Source Code Setup";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckGLEntry(Rec, GlobalGLEntry, IsHandled);
if IsHandled then
exit;
if GlobalGLEntry."Journal Batch Name" <> '' then
exit;
SourceCodeSetup.Get();
if GlobalGLEntry."Source Code" = SourceCodeSetup."Payment Reconciliation Journal" then
exit;
if GlobalGLEntry."Source Code" = SourceCodeSetup."Trans. Bank Rec. to Gen. Jnl." then
exit;
TestFieldError();
end;
local procedure CheckGLAcc(GLEntry: Record "G/L Entry"; var BalanceCheckAmount: Decimal; var BalanceCheckAddCurrAmount: Decimal)
var
GLAccount: Record "G/L Account";
IsHandled: Boolean;
begin
OnBeforeCheckGLAcc(GLEntry);
GLAccount.Get(GLEntry."G/L Account No.");
JnlTemplName := GLEntry."Journal Templ. Name";
CheckPostingDate(GLEntry."Posting Date", GLEntry.TableCaption(), GLEntry."Entry No.");
IsHandled := false;
OnCheckGLAccOnBeforeTestFields(GLAccount, GLEntry, IsHandled);
if not IsHandled then begin
GLAccount.TestField(Blocked, false);
GLEntry.TestField("Job No.", '');
end;
if GLEntry.Reversed then
AlreadyReversedEntry(GLEntry.TableCaption(), GLEntry."Entry No.");
BalanceCheckAmount := BalanceCheckAmount + GLEntry.Amount;
if GLSetup."Additional Reporting Currency" <> '' then
BalanceCheckAddCurrAmount := BalanceCheckAddCurrAmount + GLEntry."Additional-Currency Amount";
OnAfterCheckGLAcc(GLAccount, GLEntry);
end;
local procedure CheckCust(CustLedgerEntry: Record "Cust. Ledger Entry")
var
Customer: Record Customer;
begin
OnBeforeCheckCust(CustLedgerEntry);
Customer.Get(CustLedgerEntry."Customer No.");
JnlTemplName := CustLedgerEntry."Journal Templ. Name";
CheckPostingDate(CustLedgerEntry."Posting Date", CustLedgerEntry.TableCaption(), CustLedgerEntry."Entry No.");
Customer.CheckBlockedCustOnJnls(Customer, CustLedgerEntry."Document Type", false);
if CustLedgerEntry.Reversed then
AlreadyReversedEntry(CustLedgerEntry.TableCaption(), CustLedgerEntry."Entry No.");
CheckDtldCustLedgEntry(CustLedgerEntry);
OnAfterCheckCust(Customer, CustLedgerEntry);
end;
local procedure CheckVend(VendorLedgerEntry: Record "Vendor Ledger Entry")
var
Vendor: Record Vendor;
begin
OnBeforeCheckVend(VendorLedgerEntry);
Vendor.Get(VendorLedgerEntry."Vendor No.");
JnlTemplName := VendorLedgerEntry."Journal Templ. Name";
CheckPostingDate(VendorLedgerEntry."Posting Date", VendorLedgerEntry.TableCaption(), VendorLedgerEntry."Entry No.");
Vendor.CheckBlockedVendOnJnls(Vendor, VendorLedgerEntry."Document Type", false);
if VendorLedgerEntry.Reversed then
AlreadyReversedEntry(VendorLedgerEntry.TableCaption(), VendorLedgerEntry."Entry No.");
CheckDtldVendLedgEntry(VendorLedgerEntry);
OnAfterCheckVend(Vendor, VendorLedgerEntry);
end;
local procedure CheckEmpl(EmployeeLedgerEntry2: Record "Employee Ledger Entry")
var
Employee: Record Employee;
begin
OnBeforeCheckEmpl(EmployeeLedgerEntry2);
Employee.Get(EmployeeLedgerEntry2."Employee No.");
JnlTemplName := EmployeeLedgerEntry2."Journal Templ. Name";
CheckPostingDate(EmployeeLedgerEntry2."Posting Date", EmployeeLedgerEntry2.TableCaption(), EmployeeLedgerEntry2."Entry No.");
Employee.CheckBlockedEmployeeOnJnls(false);
if EmployeeLedgerEntry2.Reversed then
AlreadyReversedEntry(EmployeeLedgerEntry2.TableCaption(), EmployeeLedgerEntry2."Entry No.");
CheckDtldEmplLedgEntry(EmployeeLedgerEntry2);
OnAfterCheckEmpl(Employee, EmployeeLedgerEntry2);
end;
local procedure CheckBankAcc(BankAccountLedgerEntry: Record "Bank Account Ledger Entry")
var
BankAccount: Record "Bank Account";
CheckLedgerEntry: Record "Check Ledger Entry";
IsHandled: Boolean;
SkipBankAccLedgEntryOpenCheck: Boolean;
SkipBankAccLedgEntryStatementNoCheck: Boolean;
begin
IsHandled := false;
SkipBankAccLedgEntryOpenCheck := false;
SkipBankAccLedgEntryStatementNoCheck := false;
OnBeforeCheckBankAcc(BankAccountLedgerEntry, IsHandled, SkipBankAccLedgEntryOpenCheck, SkipBankAccLedgEntryStatementNoCheck);
if IsHandled then
exit;
BankAccount.Get(BankAccountLedgerEntry."Bank Account No.");
JnlTemplName := BankAccountLedgerEntry."Journal Templ. Name";
CheckPostingDate(BankAccountLedgerEntry."Posting Date", BankAccountLedgerEntry.TableCaption(), BankAccountLedgerEntry."Entry No.");
BankAccount.TestField(Blocked, false);
if BankAccountLedgerEntry.Reversed then
AlreadyReversedEntry(BankAccountLedgerEntry.TableCaption(), BankAccountLedgerEntry."Entry No.");
if (not SkipBankAccLedgEntryOpenCheck) and (not BankAccountLedgerEntry.Open) then
Error(
Text006, BankAccountLedgerEntry.TableCaption(), BankAccountLedgerEntry."Entry No.");
if (not SkipBankAccLedgEntryStatementNoCheck) and (BankAccountLedgerEntry."Statement No." <> '') then
Error(
Text007, BankAccountLedgerEntry.TableCaption(), BankAccountLedgerEntry."Entry No.");
CheckLedgerEntry.SetRange("Bank Account Ledger Entry No.", BankAccountLedgerEntry."Entry No.");
if not CheckLedgerEntry.IsEmpty() then
Error(
Text003, BankAccountLedgerEntry.TableCaption(), BankAccountLedgerEntry."Entry No.");
OnAfterCheckBankAcc(BankAccount, BankAccountLedgerEntry);
end;
local procedure CheckFA(FALedgerEntry: Record "FA Ledger Entry")
var
FixedAsset: Record "Fixed Asset";
FADepreciationBook: Record "FA Depreciation Book";
DepreciationCalculation: Codeunit "Depreciation Calculation";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckFA(FALedgerEntry, IsHandled);
if IsHandled then
exit;
FixedAsset.Get(FALedgerEntry."FA No.");
CheckPostingDate(FALedgerEntry."Posting Date", FALedgerEntry.TableCaption(), FALedgerEntry."Entry No.");
CheckFAPostingDate(FALedgerEntry."FA Posting Date", FALedgerEntry.TableCaption(), FALedgerEntry."Entry No.");
FixedAsset.TestField(Blocked, false);
FixedAsset.TestField(Inactive, false);
if FALedgerEntry.Reversed then
AlreadyReversedEntry(FALedgerEntry.TableCaption(), FALedgerEntry."Entry No.");
FALedgerEntry.TestField("Depreciation Book Code");
FADepreciationBook.Get(FixedAsset."No.", FALedgerEntry."Depreciation Book Code");
if FADepreciationBook."Disposal Date" <> 0D then
Error(Text008, DepreciationCalculation.FAName(FixedAsset, FALedgerEntry."Depreciation Book Code"));
FALedgerEntry.TestField("G/L Entry No.");
OnAfterCheckFA(FixedAsset, FALedgerEntry);
end;
local procedure CheckMaintenance(MaintenanceLedgerEntry: Record "Maintenance Ledger Entry")
var
FixedAsset: Record "Fixed Asset";
FADepreciationBook: Record "FA Depreciation Book";
begin
OnBeforeCheckMaintenance(MaintenanceLedgerEntry);
FixedAsset.Get(MaintenanceLedgerEntry."FA No.");
CheckPostingDate(MaintenanceLedgerEntry."Posting Date", MaintenanceLedgerEntry.TableCaption(), MaintenanceLedgerEntry."Entry No.");
CheckFAPostingDate(MaintenanceLedgerEntry."FA Posting Date", MaintenanceLedgerEntry.TableCaption(), MaintenanceLedgerEntry."Entry No.");
FixedAsset.TestField(Blocked, false);
FixedAsset.TestField(Inactive, false);
MaintenanceLedgerEntry.TestField("Depreciation Book Code");
if MaintenanceLedgerEntry.Reversed then
AlreadyReversedEntry(MaintenanceLedgerEntry.TableCaption(), MaintenanceLedgerEntry."Entry No.");
FADepreciationBook.Get(FixedAsset."No.", MaintenanceLedgerEntry."Depreciation Book Code");
MaintenanceLedgerEntry.TestField("G/L Entry No.");
OnAfterCheckMaintenance(FixedAsset, MaintenanceLedgerEntry);
end;
local procedure CheckVAT(VATEntry: Record "VAT Entry")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckVAT(VATEntry, IsHandled);
if IsHandled then
exit;
JnlTemplName := VATEntry."Journal Templ. Name";
CheckPostingDate(VATEntry."Posting Date", VATEntry.TableCaption(), VATEntry."Entry No.");
if VATEntry.Closed then
Error(
Text006, VATEntry.TableCaption(), VATEntry."Entry No.");
if VATEntry.Reversed then
AlreadyReversedEntry(VATEntry.TableCaption(), VATEntry."Entry No.");
OnAfterCheckVAT(VATEntry);
end;
local procedure CheckDtldCustLedgEntry(CustLedgerEntry: Record "Cust. Ledger Entry")
var
DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckDtldCustLedgEntry(CustLedgerEntry, IsHandled);
if IsHandled then
exit;
DetailedCustLedgEntry.SetCurrentKey("Cust. Ledger Entry No.", "Entry Type");
DetailedCustLedgEntry.SetRange("Cust. Ledger Entry No.", CustLedgerEntry."Entry No.");
DetailedCustLedgEntry.SetFilter("Entry Type", '<>%1', DetailedCustLedgEntry."Entry Type"::"Initial Entry");
DetailedCustLedgEntry.SetRange(Unapplied, false);
if not DetailedCustLedgEntry.IsEmpty() then
Error(ReversalErrorForChangedEntry(CustLedgerEntry.TableCaption(), CustLedgerEntry."Entry No."));
GLSetup.Get();
if GLSetup."Additional Reporting Currency" <> '' then begin
DetailedCustLedgEntry.Reset();
DetailedCustLedgEntry.SetCurrentKey("Transaction No.", "Customer No.", "Entry Type");
DetailedCustLedgEntry.SetRange("Transaction No.", CustLedgerEntry."Transaction No.");
DetailedCustLedgEntry.SetRange("Customer No.", CustLedgerEntry."Customer No.");
DetailedCustLedgEntry.SetFilter("Entry Type", '%1|%2',
DetailedCustLedgEntry."Entry Type"::"Realized Gain", DetailedCustLedgEntry."Entry Type"::"Realized Loss");
if not DetailedCustLedgEntry.IsEmpty() then
Error(ReversalWithACYErr);
end;
OnAfterCheckDtldCustLedgEntry(DetailedCustLedgEntry, CustLedgerEntry);
end;
local procedure CheckDtldVendLedgEntry(VendorLedgerEntry: Record "Vendor Ledger Entry")
var
DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCCheckDtldVendLedgEntry(VendorLedgerEntry, IsHandled);
if IsHandled then
exit;
DetailedVendorLedgEntry.SetCurrentKey("Vendor Ledger Entry No.", "Entry Type");
DetailedVendorLedgEntry.SetRange("Vendor Ledger Entry No.", VendorLedgerEntry."Entry No.");
DetailedVendorLedgEntry.SetFilter("Entry Type", '<>%1', DetailedVendorLedgEntry."Entry Type"::"Initial Entry");
DetailedVendorLedgEntry.SetRange(Unapplied, false);
if not DetailedVendorLedgEntry.IsEmpty() then
Error(ReversalErrorForChangedEntry(VendorLedgerEntry.TableCaption(), VendorLedgerEntry."Entry No."));
GLSetup.Get();
if GLSetup."Additional Reporting Currency" <> '' then begin
DetailedVendorLedgEntry.Reset();
DetailedVendorLedgEntry.SetCurrentKey("Transaction No.", "Vendor No.", "Entry Type");
DetailedVendorLedgEntry.SetRange("Transaction No.", VendorLedgerEntry."Transaction No.");
DetailedVendorLedgEntry.SetRange("Vendor No.", VendorLedgerEntry."Vendor No.");
DetailedVendorLedgEntry.SetFilter("Entry Type", '%1|%2',
DetailedVendorLedgEntry."Entry Type"::"Realized Gain", DetailedVendorLedgEntry."Entry Type"::"Realized Loss");
if not DetailedVendorLedgEntry.IsEmpty() then
Error(ReversalWithACYErr);
end;
OnAfterCheckDtldVendLedgEntry(DetailedVendorLedgEntry, VendorLedgerEntry);
end;
local procedure CheckDtldEmplLedgEntry(EmployeeLedgerEntry2: Record "Employee Ledger Entry")
var
DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry";
begin
DetailedEmployeeLedgerEntry.SetRange("Employee Ledger Entry No.", EmployeeLedgerEntry2."Entry No.");
DetailedEmployeeLedgerEntry.SetFilter("Entry Type", '<>%1', DetailedEmployeeLedgerEntry."Entry Type"::"Initial Entry");
DetailedEmployeeLedgerEntry.SetRange(Unapplied, false);
if not DetailedEmployeeLedgerEntry.IsEmpty() then
Error(ReversalErrorForChangedEntry(EmployeeLedgerEntry2.TableCaption(), EmployeeLedgerEntry2."Entry No."));
OnAfterCheckDtldEmplLedgEntry(DetailedEmployeeLedgerEntry, EmployeeLedgerEntry2);
end;
local procedure CheckRegister(RegisterNo: Integer)
var
GLRegister: Record "G/L Register";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckRegister(RegisterNo, IsHandled, Rec);
if IsHandled then
exit;
GLRegister.Get(RegisterNo);
if GLRegister.Reversed then
Error(Text010, GLRegister.TableCaption(), GLRegister."No.");
if GLRegister."Journal Batch Name" = '' then
TempReversalEntry.TestFieldError();
end;
/// <summary>
/// Sets up filters on ledger entry tables for reversal processing based on transaction or register number.
/// </summary>
/// <param name="Number">Transaction or register number to filter by</param>
/// <param name="RevType">Type of reversal (Transaction or Register)</param>
procedure SetReverseFilter(Number: Integer; RevType: Option Transaction,Register)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeSetReverseFilter(Number, RevType, GlobalGLEntry, GlobalCustLedgerEntry, GlobalVendorLedgerEntry, GlobalEmployeeLedgerEntry, GlobalBankAccountLedgerEntry, GlobalVATEntry, GlobalFALedgerEntry, GlobalMaintenanceLedgerEntry, GlobalGLRegister, Rec, IsHandled);
if IsHandled then
exit;
if RevType = RevType::Transaction then begin
GlobalGLEntry.SetCurrentKey("Transaction No.");
GlobalCustLedgerEntry.SetCurrentKey("Transaction No.");
GlobalVendorLedgerEntry.SetCurrentKey("Transaction No.");
GlobalEmployeeLedgerEntry.SetCurrentKey("Transaction No.");
GlobalBankAccountLedgerEntry.SetCurrentKey("Transaction No.");
GlobalFALedgerEntry.SetCurrentKey("Transaction No.");
GlobalMaintenanceLedgerEntry.SetCurrentKey("Transaction No.");
GlobalVATEntry.SetCurrentKey("Transaction No.");
GlobalGLEntry.SetRange("Transaction No.", Number);
GlobalCustLedgerEntry.SetRange("Transaction No.", Number);
GlobalVendorLedgerEntry.SetRange("Transaction No.", Number);
GlobalEmployeeLedgerEntry.SetRange("Transaction No.", Number);
GlobalBankAccountLedgerEntry.SetRange("Transaction No.", Number);
GlobalFALedgerEntry.SetRange("Transaction No.", Number);
GlobalFALedgerEntry.SetFilter("G/L Entry No.", '<>%1', 0);
GlobalMaintenanceLedgerEntry.SetRange("Transaction No.", Number);
GlobalVATEntry.SetRange("Transaction No.", Number);
end else begin
GlobalGLRegister.Get(Number);
GlobalGLEntry.SetRange("Entry No.", GlobalGLRegister."From Entry No.", GlobalGLRegister."To Entry No.");
GlobalCustLedgerEntry.SetRange("Entry No.", GlobalGLRegister."From Entry No.", GlobalGLRegister."To Entry No.");
GlobalVendorLedgerEntry.SetRange("Entry No.", GlobalGLRegister."From Entry No.", GlobalGLRegister."To Entry No.");
GlobalEmployeeLedgerEntry.SetRange("Entry No.", GlobalGLRegister."From Entry No.", GlobalGLRegister."To Entry No.");
GlobalBankAccountLedgerEntry.SetRange("Entry No.", GlobalGLRegister."From Entry No.", GlobalGLRegister."To Entry No.");
GlobalFALedgerEntry.SetCurrentKey("G/L Entry No.");
GlobalFALedgerEntry.SetRange("G/L Entry No.", GlobalGLRegister."From Entry No.", GlobalGLRegister."To Entry No.");
GlobalMaintenanceLedgerEntry.SetCurrentKey("G/L Entry No.");
GlobalMaintenanceLedgerEntry.SetRange("G/L Entry No.", GlobalGLRegister."From Entry No.", GlobalGLRegister."To Entry No.");
GlobalVATEntry.SetRange("Entry No.", GlobalGLRegister."From VAT Entry No.", GlobalGLRegister."To VAT Entry No.");
end;
OnAfterSetReverseFilter(Number, RevType, GlobalGLRegister, Rec);
end;
/// <summary>
/// Copies reversal filters from global ledger entry variables to passed ledger entry record variables.
/// </summary>
/// <param name="GLEntry">G/L Entry record variable to copy filters to</param>
/// <param name="CustLedgerEntry">Customer Ledger Entry record variable to copy filters to</param>
/// <param name="VendorLedgerEntry">Vendor Ledger Entry record variable to copy filters to</param>
/// <param name="BankAccountLedgerEntry">Bank Account Ledger Entry record variable to copy filters to</param>
/// <param name="VATEntry">VAT Entry record variable to copy filters to</param>
/// <param name="FALedgerEntry">Fixed Asset Ledger Entry record variable to copy filters to</param>
/// <param name="MaintenanceLedgerEntry">Maintenance Ledger Entry record variable to copy filters to</param>
/// <param name="EmployeeLedgerEntry">Employee Ledger Entry record variable to copy filters to</param>
procedure CopyReverseFilters(var GLEntry: Record "G/L Entry"; var CustLedgerEntry: Record "Cust. Ledger Entry"; var VendorLedgerEntry: Record "Vendor Ledger Entry"; var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; var VATEntry: Record "VAT Entry"; var FALedgerEntry: Record "FA Ledger Entry"; var MaintenanceLedgerEntry: Record "Maintenance Ledger Entry"; var EmployeeLedgerEntry: Record "Employee Ledger Entry")
begin
GLEntry.Copy(GlobalGLEntry);
CustLedgerEntry.Copy(GlobalCustLedgerEntry);
VendorLedgerEntry.Copy(GlobalVendorLedgerEntry);
EmployeeLedgerEntry.Copy(GlobalEmployeeLedgerEntry);
BankAccountLedgerEntry.Copy(GlobalBankAccountLedgerEntry);
VATEntry.Copy(GlobalVATEntry);
FALedgerEntry.Copy(GlobalFALedgerEntry);
MaintenanceLedgerEntry.Copy(GlobalMaintenanceLedgerEntry);
end;
/// <summary>
/// Opens the G/L Entries page filtered for reversal candidates.
/// </summary>
procedure ShowGLEntries()
begin
PAGE.Run(0, GlobalGLEntry);
end;
/// <summary>
/// Opens the Customer Ledger Entries page filtered for reversal candidates.
/// </summary>
procedure ShowCustLedgEntries()
begin
PAGE.Run(0, GlobalCustLedgerEntry);
end;
/// <summary>
/// Opens the Vendor Ledger Entries page filtered for reversal candidates.
/// </summary>
procedure ShowVendLedgEntries()
begin
PAGE.Run(0, GlobalVendorLedgerEntry);
end;
/// <summary>
/// Opens the Bank Account Ledger Entries page filtered for reversal candidates.
/// </summary>
procedure ShowBankAccLedgEntries()
begin
PAGE.Run(0, GlobalBankAccountLedgerEntry);
end;
/// <summary>
/// Opens the Fixed Asset Ledger Entries page filtered for reversal candidates.
/// </summary>
procedure ShowFALedgEntries()
begin
PAGE.Run(0, GlobalFALedgerEntry);
end;
/// <summary>
/// Opens the Maintenance Ledger Entries page filtered for reversal candidates.
/// </summary>
procedure ShowMaintenanceLedgEntries()
begin
PAGE.Run(0, GlobalMaintenanceLedgerEntry);
end;
/// <summary>
/// Opens the VAT Entries page filtered for reversal candidates.
/// </summary>
procedure ShowVATEntries()
begin
PAGE.Run(0, GlobalVATEntry);
end;
/// <summary>
/// Returns a caption describing the entry for display purposes.
/// </summary>
/// <returns>Caption text based on entry type and source information</returns>
procedure Caption() Result: Text
var
GLAccount: Record "G/L Account";
Customer: Record Customer;
Vendor: Record Vendor;
Employee: Record Employee;
BankAccount: Record "Bank Account";
FixedAsset: Record "Fixed Asset";
NewCaption: Text;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCaption(Rec, Result, IsHandled);
if IsHandled then
exit;
case "Entry Type" of
"Entry Type"::"G/L Account":
begin
if GlobalGLEntry.Get("Entry No.") then;
if GLAccount.Get(GlobalGLEntry."G/L Account No.") then;
exit(StrSubstNo(CaptionTxt, GLAccount.TableCaption(), GLAccount."No.", GLAccount.Name));
end;
"Entry Type"::Customer:
begin
if GlobalCustLedgerEntry.Get("Entry No.") then;
if Customer.Get(GlobalCustLedgerEntry."Customer No.") then;
exit(StrSubstNo(CaptionTxt, Customer.TableCaption(), Customer."No.", Customer.Name));
end;
"Entry Type"::Vendor:
begin
if GlobalVendorLedgerEntry.Get("Entry No.") then;
if Vendor.Get(GlobalVendorLedgerEntry."Vendor No.") then;
exit(StrSubstNo(CaptionTxt, Vendor.TableCaption(), Vendor."No.", Vendor.Name));
end;
"Entry Type"::Employee:
begin
if GlobalEmployeeLedgerEntry.Get("Entry No.") then;
if Employee.Get(GlobalEmployeeLedgerEntry."Employee No.") then;
exit(StrSubstNo(CaptionTxt, Employee.TableCaption(), Employee."No.", Employee.FullName()));
end;
"Entry Type"::"Bank Account":
begin
if GlobalBankAccountLedgerEntry.Get("Entry No.") then;
if BankAccount.Get(GlobalBankAccountLedgerEntry."Bank Account No.") then;
exit(StrSubstNo(CaptionTxt, BankAccount.TableCaption(), BankAccount."No.", BankAccount.Name));
end;
"Entry Type"::"Fixed Asset":
begin
if GlobalFALedgerEntry.Get("Entry No.") then;
if FixedAsset.Get(GlobalFALedgerEntry."FA No.") then;
exit(StrSubstNo(CaptionTxt, FixedAsset.TableCaption(), FixedAsset."No.", FixedAsset.Description));
end;
"Entry Type"::Maintenance:
begin
if GlobalMaintenanceLedgerEntry.Get("Entry No.") then;
if FixedAsset.Get(GlobalMaintenanceLedgerEntry."FA No.") then;
exit(StrSubstNo(CaptionTxt, FixedAsset.TableCaption(), FixedAsset."No.", FixedAsset.Description));
end;
"Entry Type"::VAT:
exit(StrSubstNo('%1', GlobalVATEntry.TableCaption()));
else begin
OnAfterCaption(Rec, NewCaption);
exit(NewCaption);
end;
end;
end;
/// <summary>
/// Validates that the posting date allows reversal based on allowed posting date range.
/// </summary>
/// <param name="PostingDate">Posting date to validate</param>
/// <param name="TableCaption">Table caption for error messaging</param>
/// <param name="EntryNo">Entry number for error messaging</param>
procedure CheckPostingDate(PostingDate: Date; TableCaption: Text; EntryNo: Integer)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckPostingDate(PostingDate, CopyStr(TableCaption, 1, 50), EntryNo, IsHandled, Rec, MaxPostingDate);
if IsHandled then
exit;
if GenJnlCheckLine.DateNotAllowed(PostingDate, JnlTemplName) then
Error(Text001, TableCaption, EntryNo);
if PostingDate > MaxPostingDate then
MaxPostingDate := PostingDate;
end;
/// <summary>
/// Validates that the Fixed Asset posting date allows reversal based on FA allowed posting date range.
/// </summary>
/// <param name="FAPostingDate">FA posting date to validate</param>
/// <param name="TableCaption">Table caption for error messaging</param>
/// <param name="EntryNo">Entry number for error messaging</param>
procedure CheckFAPostingDate(FAPostingDate: Date; TableCaption: Text; EntryNo: Integer)
var
UserSetup: Record "User Setup";
FASetup: Record "FA Setup";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckFAPostingDate(FAPostingDate, CopyStr(TableCaption, 1, 50), EntryNo, IsHandled, Rec, MaxPostingDate, AllowPostingFrom, AllowPostingto, xRec);
if IsHandled then
exit;
if (AllowPostingFrom = 0D) and (AllowPostingto = 0D) then begin
if UserId <> '' then
if UserSetup.Get(UserId) then begin
AllowPostingFrom := UserSetup."Allow FA Posting From";
AllowPostingto := UserSetup."Allow FA Posting To";
end;
if (AllowPostingFrom = 0D) and (AllowPostingto = 0D) then begin
FASetup.Get();
AllowPostingFrom := FASetup."Allow FA Posting From";
AllowPostingto := FASetup."Allow FA Posting To";
end;
if AllowPostingto = 0D then
AllowPostingto := 99981231D;
end;
if (FAPostingDate < AllowPostingFrom) or (FAPostingDate > AllowPostingto) then
Error(Text005, TableCaption, EntryNo, GlobalFALedgerEntry.FieldCaption("FA Posting Date"));
if FAPostingDate > MaxPostingDate then
MaxPostingDate := FAPostingDate;
end;
/// <summary>
/// Raises an error indicating missing required field values for reversal operation.
/// </summary>
procedure TestFieldError()
begin
Error(Text004);
end;
/// <summary>
/// Raises an error indicating the entry has already been reversed.
/// </summary>
/// <param name="TableCaption">Table caption for error messaging</param>
/// <param name="EntryNo">Entry number that was already reversed</param>
procedure AlreadyReversedEntry(TableCaption: Text; EntryNo: Integer)
begin
Error(Text011, TableCaption, EntryNo);
end;
/// <summary>
/// Verifies that reversal entries are valid and consistent for the specified transaction or register.
/// </summary>
/// <param name="ReversalEntry2">Reversal entry record to compare against</param>
/// <param name="Number">Transaction or register number to verify</param>
/// <param name="RevType">Type of reversal (Transaction or Register)</param>
/// <returns>True if reversal entries are valid, false otherwise</returns>
procedure VerifyReversalEntries(var ReversalEntry2: Record "Reversal Entry"; Number: Integer; RevType: Option Transaction,Register) Result: Boolean
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeVerifyReversalEntries(ReversalEntry2, Number, RevType, IsHandled, Result);
if IsHandled then
exit(Result);
InsertReversalEntry(Number, RevType);
Clear(TempReversalEntry);
Clear(ReversalEntry2);
if ReversalEntry2.FindSet() then
repeat
if TempReversalEntry.Next() = 0 then
exit(false);
if not TempReversalEntry.Equal(ReversalEntry2) then
exit(false);
until ReversalEntry2.Next() = 0;
exit(TempReversalEntry.Next() = 0);
end;
/// <summary>
/// Compares two reversal entries for equality based on Entry Type and Entry No.
/// </summary>
/// <param name="ReversalEntry2">Reversal entry to compare against</param>
/// <returns>True if entries are equal, false otherwise</returns>
procedure Equal(ReversalEntry2: Record "Reversal Entry"): Boolean
begin
exit(
("Entry Type" = ReversalEntry2."Entry Type") and
("Entry No." = ReversalEntry2."Entry No."));
end;
/// <summary>
/// Returns an error message for entries that have been changed since reversal preparation.
/// </summary>
/// <param name="TableCaption">Table caption for error messaging</param>
/// <param name="EntryNo">Entry number that has changed</param>
/// <returns>Formatted error message text</returns>
procedure ReversalErrorForChangedEntry(TableCaption: Text; EntryNo: Integer): Text[1024]
begin
exit(StrSubstNo(Text000, TableCaption, EntryNo));
end;
/// <summary>
/// Sets whether to hide dialog boxes during reversal processing.
/// </summary>
/// <param name="NewHideDialog">True to hide dialogs, false to show dialogs</param>
procedure SetHideDialog(NewHideDialog: Boolean)
begin
HideDialog := NewHideDialog;
end;
/// <summary>
/// Sets both dialog hiding and warning dialog hiding for batch processing.
/// </summary>
procedure SetHideWarningDialogs()
begin
HideDialog := true;
HideWarningDialogs := true;
end;
/// <summary>
/// Sets the bank account statement context for bank account ledger entry reversals.
/// </summary>
/// <param name="BankAccountNo">Bank account number</param>
/// <param name="StatementNo">Bank statement number</param>
procedure SetBankAccountStatement(BankAccountNo: Code[20]; StatementNo: Code[20])
begin
BankAccountStatement.Get(BankAccountNo, StatementNo);
end;
protected procedure InsertFromCustLedgEntry(var TempTransactionInteger: Record "Integer" temporary; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer)
var
Customer: Record Customer;
DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry";
IsHandled: Boolean;
begin
DetailedCustLedgEntry.SetCurrentKey("Transaction No.", "Customer No.", "Entry Type");
DetailedCustLedgEntry.SetFilter(
"Entry Type", '<>%1', DetailedCustLedgEntry."Entry Type"::"Initial Entry");
if GlobalCustLedgerEntry.FindSet() then
repeat
DetailedCustLedgEntry.SetRange("Transaction No.", GlobalCustLedgerEntry."Transaction No.");
DetailedCustLedgEntry.SetRange("Customer No.", GlobalCustLedgerEntry."Customer No.");
IsHandled := false;
OnInsertFromCustLedgEntryOnBeforeCheckSameTransaction(GlobalCustLedgerEntry, DetailedCustLedgEntry, IsHandled);
if not IsHandled then
if (not DetailedCustLedgEntry.IsEmpty) and (RevType = RevType::Register) then
Error(PostedAndAppliedSameTransactionErr, Number);
Clear(TempReversalEntry);
if RevType = RevType::Register then
TempReversalEntry."G/L Register No." := Number;
TempReversalEntry."Reversal Type" := RevType;
TempReversalEntry."Entry Type" := TempReversalEntry."Entry Type"::Customer;
Customer.Get(GlobalCustLedgerEntry."Customer No.");
TempReversalEntry."Account No." := Customer."No.";
TempReversalEntry."Account Name" := Customer.Name;
TempReversalEntry.CopyFromCustLedgEntry(GlobalCustLedgerEntry);
TempReversalEntry."Line No." := NextLineNo;
NextLineNo := NextLineNo + 1;
OnInsertFromCustLedgEntryOnBeforeTempReversalEntryInsert(TempReversalEntry, GlobalCustLedgerEntry);
TempReversalEntry.Insert();
DetailedCustLedgEntry.SetRange(Unapplied, true);
if DetailedCustLedgEntry.FindSet() then
repeat
InsertCustTempRevertTransNo(TempTransactionInteger, DetailedCustLedgEntry."Unapplied by Entry No.");
until DetailedCustLedgEntry.Next() = 0;
DetailedCustLedgEntry.SetRange(Unapplied);
until GlobalCustLedgerEntry.Next() = 0;
OnAfterInsertFromCustLedgEntry(TempTransactionInteger, Number, RevType, NextLineNo, TempReversalEntry, GlobalCustLedgerEntry);
end;
protected procedure InsertFromVendLedgEntry(var TempTransactionNoInteger: Record "Integer" temporary; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer)
var
Vendor: Record Vendor;
DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry";
IsHandled: Boolean;
begin
DetailedVendorLedgEntry.SetCurrentKey("Transaction No.", "Vendor No.", "Entry Type");
DetailedVendorLedgEntry.SetFilter(
"Entry Type", '<>%1', DetailedVendorLedgEntry."Entry Type"::"Initial Entry");
if GlobalVendorLedgerEntry.FindSet() then
repeat
DetailedVendorLedgEntry.SetRange("Transaction No.", GlobalVendorLedgerEntry."Transaction No.");
DetailedVendorLedgEntry.SetRange("Vendor No.", GlobalVendorLedgerEntry."Vendor No.");
IsHandled := false;
OnInsertFromVendLedgEntryOnBeforeCheckSameTransaction(GlobalVendorLedgerEntry, DetailedVendorLedgEntry, IsHandled);
if not IsHandled then
if (not DetailedVendorLedgEntry.IsEmpty()) and (RevType = RevType::Register) then
Error(PostedAndAppliedSameTransactionErr, Number);
Clear(TempReversalEntry);
if RevType = RevType::Register then
TempReversalEntry."G/L Register No." := Number;
TempReversalEntry."Reversal Type" := RevType;
TempReversalEntry."Entry Type" := TempReversalEntry."Entry Type"::Vendor;
Vendor.Get(GlobalVendorLedgerEntry."Vendor No.");
TempReversalEntry."Account No." := Vendor."No.";
TempReversalEntry."Account Name" := Vendor.Name;
TempReversalEntry.CopyFromVendLedgEntry(GlobalVendorLedgerEntry);
TempReversalEntry."Line No." := NextLineNo;
NextLineNo := NextLineNo + 1;
OnInsertFromVendLedgEntryOnBeforeTempReversalEntryInsert(TempReversalEntry, GlobalVendorLedgerEntry);
TempReversalEntry.Insert();
DetailedVendorLedgEntry.SetRange(Unapplied, true);
if DetailedVendorLedgEntry.FindSet() then
repeat
InsertVendTempRevertTransNo(TempTransactionNoInteger, DetailedVendorLedgEntry."Unapplied by Entry No.");
until DetailedVendorLedgEntry.Next() = 0;
DetailedVendorLedgEntry.SetRange(Unapplied);
until GlobalVendorLedgerEntry.Next() = 0;
OnAfterInsertFromVendLedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo, TempReversalEntry, GlobalVendorLedgerEntry);
end;
protected procedure InsertFromEmplLedgerEntry(var TempTransactionNoInteger: Record "Integer" temporary; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer)
var
DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry";
begin
DetailedEmployeeLedgerEntry.SetCurrentKey("Transaction No.", "Employee No.", "Entry Type");
DetailedEmployeeLedgerEntry.SetFilter(
"Entry Type", '<>%1', DetailedEmployeeLedgerEntry."Entry Type"::"Initial Entry");
if GlobalEmployeeLedgerEntry.FindSet() then
repeat
DetailedEmployeeLedgerEntry.SetRange("Transaction No.", GlobalEmployeeLedgerEntry."Transaction No.");
DetailedEmployeeLedgerEntry.SetRange("Employee No.", GlobalEmployeeLedgerEntry."Employee No.");
if (not DetailedEmployeeLedgerEntry.IsEmpty) and (RevType = RevType::Register) then
Error(PostedAndAppliedSameTransactionErr, Number);
InsertTempReversalEntryEmployee(Number, RevType, NextLineNo);
NextLineNo += 1;
InsertTempRevertTransactionNoUnappliedEmployeeEntries(TempTransactionNoInteger, DetailedEmployeeLedgerEntry);
until GlobalEmployeeLedgerEntry.Next() = 0;
OnAfterInsertFromEmplLedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo, TempReversalEntry, GlobalEmployeeLedgerEntry);
end;
protected procedure InsertFromBankAccLedgEntry(TempTransactionNoInteger: Record "Integer" temporary; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer)
var
BankAccount: Record "Bank Account";
begin
if GlobalBankAccountLedgerEntry.FindSet() then
repeat
OnInsertFromBankAccLedgEntryOnStartRepeatBankAccLedgEntry(GlobalBankAccountLedgerEntry);
Clear(TempReversalEntry);
if RevType = RevType::Register then
TempReversalEntry."G/L Register No." := Number;
TempReversalEntry."Reversal Type" := RevType;
TempReversalEntry."Entry Type" := TempReversalEntry."Entry Type"::"Bank Account";
BankAccount.Get(GlobalBankAccountLedgerEntry."Bank Account No.");
TempReversalEntry."Account No." := BankAccount."No.";
TempReversalEntry."Account Name" := BankAccount.Name;
TempReversalEntry.CopyFromBankAccLedgEntry(GlobalBankAccountLedgerEntry);
TempReversalEntry."Line No." := NextLineNo;
NextLineNo := NextLineNo + 1;
TempReversalEntry.Insert();
until GlobalBankAccountLedgerEntry.Next() = 0;
OnAfterInsertFromBankAccLedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo, TempReversalEntry, GlobalBankAccountLedgerEntry);
end;
protected procedure InsertFromFALedgEntry(TempTransactionNoInteger: Record "Integer" temporary; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer)
var
FixedAsset: Record "Fixed Asset";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeInsertFromFALedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo, TempReversalEntry, GlobalFALedgerEntry, IsHandled);
if IsHandled then
exit;
if GlobalFALedgerEntry.FindSet() then
repeat
Clear(TempReversalEntry);
if RevType = RevType::Register then
TempReversalEntry."G/L Register No." := Number;
TempReversalEntry."Reversal Type" := RevType;
TempReversalEntry."Entry Type" := TempReversalEntry."Entry Type"::"Fixed Asset";
FixedAsset.Get(GlobalFALedgerEntry."FA No.");
TempReversalEntry."Account No." := FixedAsset."No.";
TempReversalEntry."Account Name" := FixedAsset.Description;
TempReversalEntry.CopyFromFALedgEntry(GlobalFALedgerEntry);
if GlobalFALedgerEntry."FA Posting Type" <> GlobalFALedgerEntry."FA Posting Type"::"Salvage Value" then begin
TempReversalEntry."Line No." := NextLineNo;
NextLineNo := NextLineNo + 1;
TempReversalEntry.Insert();
end;
until GlobalFALedgerEntry.Next() = 0;
OnAfterInsertFromFALedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo, TempReversalEntry, GlobalFALedgerEntry);
end;
protected procedure InsertFromMaintenanceLedgEntry(TempTransactionNoInteger: Record "Integer" temporary; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer)
var
FixedAsset: Record "Fixed Asset";
begin
if GlobalMaintenanceLedgerEntry.FindSet() then
repeat
Clear(TempReversalEntry);
if RevType = RevType::Register then
TempReversalEntry."G/L Register No." := Number;
TempReversalEntry."Reversal Type" := RevType;
TempReversalEntry."Entry Type" := TempReversalEntry."Entry Type"::Maintenance;
FixedAsset.Get(GlobalMaintenanceLedgerEntry."FA No.");
TempReversalEntry."Account No." := FixedAsset."No.";
TempReversalEntry."Account Name" := FixedAsset.Description;
TempReversalEntry.CopyFromMaintenanceEntry(GlobalMaintenanceLedgerEntry);
TempReversalEntry."Line No." := NextLineNo;
NextLineNo := NextLineNo + 1;
TempReversalEntry.Insert();
until GlobalMaintenanceLedgerEntry.Next() = 0;
OnAfterInsertFromMaintenanceLedgEntry(TempTransactionNoInteger, Number, RevType, NextLineNo, TempReversalEntry, GlobalMaintenanceLedgerEntry);
end;
protected procedure InsertFromVATEntry(var TempTransactionNoInteger: Record "Integer" temporary; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer)
begin
TempTransactionNoInteger.FindSet();
repeat
if RevType = RevType::Transaction then
GlobalVATEntry.SetRange("Transaction No.", TempTransactionNoInteger.Number);
OnInsertFromVATEntryOnAfterVATEntrySetRange(GlobalVATEntry, RevType, TempTransactionNoInteger);
if GlobalVATEntry.FindSet() then
repeat
OnInsertFromVATEntryOnStartRepeatVATEntry(GlobalVATEntry);
Clear(TempReversalEntry);
if RevType = RevType::Register then
TempReversalEntry."G/L Register No." := Number;
TempReversalEntry."Reversal Type" := RevType;
TempReversalEntry."Entry Type" := TempReversalEntry."Entry Type"::VAT;
TempReversalEntry.CopyFromVATEntry(GlobalVATEntry);
TempReversalEntry."Line No." := NextLineNo;
NextLineNo := NextLineNo + 1;
OnInsertFromVATEntryOnBeforeTempReversalEntryInsert(TempReversalEntry, RevType, TempTransactionNoInteger);
TempReversalEntry.Insert();
until GlobalVATEntry.Next() = 0;
until TempTransactionNoInteger.Next() = 0;
OnAfterInsertFromVATEntry(TempTransactionNoInteger, Number, RevType, NextLineNo, TempReversalEntry, GlobalVATEntry);
end;
protected procedure InsertFromGLEntry(var TempTransactionNoInteger: Record "Integer" temporary; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer)
var
GLAccount: Record "G/L Account";
begin
TempTransactionNoInteger.FindSet();
repeat
if RevType = RevType::Transaction then
GlobalGLEntry.SetRange("Transaction No.", TempTransactionNoInteger.Number);
OnInsertFromGLEntryOnAfterGLEntrySetRange(GlobalGLEntry, RevType, TempTransactionNoInteger);
if GlobalGLEntry.FindSet() then
repeat
OnInsertFromGLEntryOnBeforeClearTempReversalEntry(GlobalGLEntry);
Clear(TempReversalEntry);
if RevType = RevType::Register then
TempReversalEntry."G/L Register No." := Number;
TempReversalEntry."Reversal Type" := RevType;
TempReversalEntry."Entry Type" := TempReversalEntry."Entry Type"::"G/L Account";
if not GLAccount.Get(GlobalGLEntry."G/L Account No.") then
Error(CannotReverseDeletedErr, GlobalGLEntry.TableCaption(), GLAccount.TableCaption());
TempReversalEntry."Account No." := GLAccount."No.";
TempReversalEntry."Account Name" := GLAccount.Name;
TempReversalEntry.CopyFromGLEntry(GlobalGLEntry);
TempReversalEntry."Line No." := NextLineNo;
NextLineNo := NextLineNo + 1;
OnInsertFromGLEntryOnBeforeTempReversalEntryInsert(TempReversalEntry, GlobalGLEntry, RevType, TempTransactionNoInteger, Rec);
TempReversalEntry.Insert();
until GlobalGLEntry.Next() = 0;
until TempTransactionNoInteger.Next() = 0;
OnAfterInsertFromGLEntry(TempTransactionNoInteger, Number, RevType, NextLineNo, TempReversalEntry, GlobalGLEntry);
end;
local procedure InsertTempReversalEntryEmployee(Number: Integer; RevType: Option Transaction,Register; NextLineNo: Integer)
var
Employee: Record Employee;
begin
Clear(TempReversalEntry);
if RevType = RevType::Register then
TempReversalEntry."G/L Register No." := Number;
TempReversalEntry."Reversal Type" := RevType;
TempReversalEntry."Entry Type" := TempReversalEntry."Entry Type"::Employee;
Employee.Get(GlobalEmployeeLedgerEntry."Employee No.");
TempReversalEntry."Account No." := Employee."No.";
TempReversalEntry."Account Name" := CopyStr(Employee.FullName(), 1, MaxStrLen(TempReversalEntry."Account Name"));
TempReversalEntry.CopyFromEmployeeLedgerEntry(GlobalEmployeeLedgerEntry);
TempReversalEntry."Line No." := NextLineNo;
TempReversalEntry.Insert();
end;
/// <summary>
/// Copies field values from a Customer Ledger Entry to populate reversal entry information.
/// </summary>
/// <param name="CustLedgerEntry">Customer Ledger Entry to copy data from</param>
procedure CopyFromCustLedgEntry(CustLedgerEntry: Record "Cust. Ledger Entry")
begin
"Entry No." := CustLedgerEntry."Entry No.";
"Posting Date" := CustLedgerEntry."Posting Date";
"Source Code" := CustLedgerEntry."Source Code";
"Journal Batch Name" := CustLedgerEntry."Journal Batch Name";
"Transaction No." := CustLedgerEntry."Transaction No.";
"Currency Code" := CustLedgerEntry."Currency Code";
Description := CustLedgerEntry.Description;
CustLedgerEntry.CalcFields(Amount, "Debit Amount", "Credit Amount",
"Amount (LCY)", "Debit Amount (LCY)", "Credit Amount (LCY)");
Amount := CustLedgerEntry.Amount;
"Debit Amount" := CustLedgerEntry."Debit Amount";
"Credit Amount" := CustLedgerEntry."Credit Amount";
"Amount (LCY)" := CustLedgerEntry."Amount (LCY)";
"Debit Amount (LCY)" := CustLedgerEntry."Debit Amount (LCY)";
"Credit Amount (LCY)" := CustLedgerEntry."Credit Amount (LCY)";
"Document Type" := CustLedgerEntry."Document Type";
"Document No." := CustLedgerEntry."Document No.";
"Bal. Account Type" := CustLedgerEntry."Bal. Account Type";
"Bal. Account No." := CustLedgerEntry."Bal. Account No.";
OnAfterCopyFromCustLedgEntry(Rec, CustLedgerEntry);
end;
/// <summary>
/// Copies field values from a Bank Account Ledger Entry to populate reversal entry information.
/// </summary>
/// <param name="BankAccountLedgerEntry">Bank Account Ledger Entry to copy data from</param>
procedure CopyFromBankAccLedgEntry(BankAccountLedgerEntry: Record "Bank Account Ledger Entry")
begin
"Entry No." := BankAccountLedgerEntry."Entry No.";
"Posting Date" := BankAccountLedgerEntry."Posting Date";
"Source Code" := BankAccountLedgerEntry."Source Code";
"Journal Batch Name" := BankAccountLedgerEntry."Journal Batch Name";
"Transaction No." := BankAccountLedgerEntry."Transaction No.";
"Currency Code" := BankAccountLedgerEntry."Currency Code";
Description := BankAccountLedgerEntry.Description;
Amount := BankAccountLedgerEntry.Amount;
"Debit Amount" := BankAccountLedgerEntry."Debit Amount";
"Credit Amount" := BankAccountLedgerEntry."Credit Amount";
"Amount (LCY)" := BankAccountLedgerEntry."Amount (LCY)";
"Debit Amount (LCY)" := BankAccountLedgerEntry."Debit Amount (LCY)";
"Credit Amount (LCY)" := BankAccountLedgerEntry."Credit Amount (LCY)";
"Document Type" := BankAccountLedgerEntry."Document Type";
"Document No." := BankAccountLedgerEntry."Document No.";
"Bal. Account Type" := BankAccountLedgerEntry."Bal. Account Type";
"Bal. Account No." := BankAccountLedgerEntry."Bal. Account No.";
OnAfterCopyFromBankAccLedgEntry(Rec, BankAccountLedgerEntry);
end;
/// <summary>
/// Copies field values from a Fixed Asset Ledger Entry to populate reversal entry information.
/// </summary>
/// <param name="FALedgerEntry">Fixed Asset Ledger Entry to copy data from</param>
procedure CopyFromFALedgEntry(FALedgerEntry: Record "FA Ledger Entry")
begin
"Entry No." := FALedgerEntry."Entry No.";
"Posting Date" := FALedgerEntry."Posting Date";
"FA Posting Category" := FALedgerEntry."FA Posting Category";
"FA Posting Type" := Enum::"Reversal Entry FA Posting Type".FromInteger(FALedgerEntry."FA Posting Type".AsInteger() + 1);
"Source Code" := FALedgerEntry."Source Code";
"Journal Batch Name" := FALedgerEntry."Journal Batch Name";
"Transaction No." := FALedgerEntry."Transaction No.";
Description := FALedgerEntry.Description;
"Amount (LCY)" := FALedgerEntry.Amount;
"Debit Amount (LCY)" := FALedgerEntry."Debit Amount";
"Credit Amount (LCY)" := FALedgerEntry."Credit Amount";
"VAT Amount" := FALedgerEntry."VAT Amount";
"Document Type" := FALedgerEntry."Document Type";
"Document No." := FALedgerEntry."Document No.";
"Bal. Account Type" := FALedgerEntry."Bal. Account Type";
"Bal. Account No." := FALedgerEntry."Bal. Account No.";
OnAfterCopyFromFALedgEntry(Rec, FALedgerEntry);
end;
/// <summary>
/// Copies field values from a G/L Entry to populate reversal entry information.
/// </summary>
/// <param name="GLEntry">G/L Entry to copy data from</param>
procedure CopyFromGLEntry(GLEntry: Record "G/L Entry")
begin
"Entry No." := GLEntry."Entry No.";
"Posting Date" := GLEntry."Posting Date";
"Source Code" := GLEntry."Source Code";
"Journal Batch Name" := GLEntry."Journal Batch Name";
"Transaction No." := GLEntry."Transaction No.";
"Source Type" := GLEntry."Source Type";
"Source No." := GLEntry."Source No.";
Description := GLEntry.Description;
"Amount (LCY)" := GLEntry.Amount;
"Source Currency Amount" := GLEntry."Source Currency Amount";
"Debit Amount (LCY)" := GLEntry."Debit Amount";
"Credit Amount (LCY)" := GLEntry."Credit Amount";
"VAT Amount" := GLEntry."VAT Amount";
"Source Currency VAT Amount" := GLEntry."Source Currency VAT Amount";
"Document Type" := GLEntry."Document Type";
"Document No." := GLEntry."Document No.";
"Bal. Account Type" := GLEntry."Bal. Account Type";
"Bal. Account No." := GLEntry."Bal. Account No.";
"Source Currency Code" := GLEntry."Source Currency Code";
OnAfterCopyFromGLEntry(Rec, GLEntry);
end;
/// <summary>
/// Copies field values from a Maintenance Ledger Entry to populate reversal entry information.
/// </summary>
/// <param name="MaintenanceLedgerEntry">Maintenance Ledger Entry to copy data from</param>
procedure CopyFromMaintenanceEntry(MaintenanceLedgerEntry: Record "Maintenance Ledger Entry")
begin
"Entry No." := MaintenanceLedgerEntry."Entry No.";
"Posting Date" := MaintenanceLedgerEntry."Posting Date";
"Source Code" := MaintenanceLedgerEntry."Source Code";
"Journal Batch Name" := MaintenanceLedgerEntry."Journal Batch Name";
"Transaction No." := MaintenanceLedgerEntry."Transaction No.";
Description := MaintenanceLedgerEntry.Description;
"Amount (LCY)" := MaintenanceLedgerEntry.Amount;
"Debit Amount (LCY)" := MaintenanceLedgerEntry."Debit Amount";
"Credit Amount (LCY)" := MaintenanceLedgerEntry."Credit Amount";
"VAT Amount" := MaintenanceLedgerEntry."VAT Amount";
"Document Type" := MaintenanceLedgerEntry."Document Type";
"Document No." := MaintenanceLedgerEntry."Document No.";
"Bal. Account Type" := MaintenanceLedgerEntry."Bal. Account Type";
"Bal. Account No." := MaintenanceLedgerEntry."Bal. Account No.";
OnAfterCopyFromMaintenanceEntry(Rec, MaintenanceLedgerEntry);
end;
/// <summary>
/// Copies field values from a VAT Entry to populate reversal entry information.
/// </summary>
/// <param name="VATEntry">VAT Entry to copy data from</param>
procedure CopyFromVATEntry(VATEntry: Record "VAT Entry")
begin
"Entry No." := VATEntry."Entry No.";
"Posting Date" := VATEntry."Posting Date";
"Source Code" := VATEntry."Source Code";
"Transaction No." := VATEntry."Transaction No.";
Amount := VATEntry.Amount;
"Amount (LCY)" := VATEntry.Amount;
"Source Currency Amount" := VATEntry."Source Currency VAT Amount";
"Document Type" := VATEntry."Document Type";
"Document No." := VATEntry."Document No.";
OnAfterCopyFromVATEntry(Rec, VATEntry);
end;
/// <summary>
/// Copies field values from a Vendor Ledger Entry to populate reversal entry information.
/// </summary>
/// <param name="VendorLedgerEntry">Vendor Ledger Entry to copy data from</param>
procedure CopyFromVendLedgEntry(VendorLedgerEntry: Record "Vendor Ledger Entry")
begin
"Entry No." := VendorLedgerEntry."Entry No.";
"Posting Date" := VendorLedgerEntry."Posting Date";
"Source Code" := VendorLedgerEntry."Source Code";
"Journal Batch Name" := VendorLedgerEntry."Journal Batch Name";
"Transaction No." := VendorLedgerEntry."Transaction No.";
"Currency Code" := VendorLedgerEntry."Currency Code";
Description := VendorLedgerEntry.Description;
VendorLedgerEntry.CalcFields(Amount, "Debit Amount", "Credit Amount",
"Amount (LCY)", "Debit Amount (LCY)", "Credit Amount (LCY)");
Amount := VendorLedgerEntry.Amount;
"Debit Amount" := VendorLedgerEntry."Debit Amount";
"Credit Amount" := VendorLedgerEntry."Credit Amount";
"Amount (LCY)" := VendorLedgerEntry."Amount (LCY)";
"Debit Amount (LCY)" := VendorLedgerEntry."Debit Amount (LCY)";
"Credit Amount (LCY)" := VendorLedgerEntry."Credit Amount (LCY)";
"Document Type" := VendorLedgerEntry."Document Type";
"Document No." := VendorLedgerEntry."Document No.";
"Bal. Account Type" := VendorLedgerEntry."Bal. Account Type";
"Bal. Account No." := VendorLedgerEntry."Bal. Account No.";
OnAfterCopyFromVendLedgEntry(Rec, VendorLedgerEntry);
end;
/// <summary>
/// Copies field values from an Employee Ledger Entry to populate reversal entry information.
/// </summary>
/// <param name="EmployeeLedgerEntry">Employee Ledger Entry to copy data from</param>
procedure CopyFromEmployeeLedgerEntry(EmployeeLedgerEntry: Record "Employee Ledger Entry")
begin
"Entry No." := EmployeeLedgerEntry."Entry No.";
"Posting Date" := EmployeeLedgerEntry."Posting Date";
"Source Code" := EmployeeLedgerEntry."Source Code";
"Journal Batch Name" := EmployeeLedgerEntry."Journal Batch Name";
"Transaction No." := EmployeeLedgerEntry."Transaction No.";
"Currency Code" := EmployeeLedgerEntry."Currency Code";
Description := EmployeeLedgerEntry.Description;
EmployeeLedgerEntry.CalcFields(
Amount, "Debit Amount", "Credit Amount", "Amount (LCY)", "Debit Amount (LCY)", "Credit Amount (LCY)");
Amount := EmployeeLedgerEntry.Amount;
"Debit Amount" := EmployeeLedgerEntry."Debit Amount";
"Credit Amount" := EmployeeLedgerEntry."Credit Amount";
"Amount (LCY)" := EmployeeLedgerEntry."Amount (LCY)";
"Debit Amount (LCY)" := EmployeeLedgerEntry."Debit Amount (LCY)";
"Credit Amount (LCY)" := EmployeeLedgerEntry."Credit Amount (LCY)";
"Document Type" := EmployeeLedgerEntry."Document Type";
"Document No." := EmployeeLedgerEntry."Document No.";
"Bal. Account Type" := EmployeeLedgerEntry."Bal. Account Type";
"Bal. Account No." := EmployeeLedgerEntry."Bal. Account No.";
OnAfterCopyFromEmplLedgEntry(Rec, EmployeeLedgerEntry);
end;
local procedure InsertCustTempRevertTransNo(var TempTransactionNoInteger: Record "Integer" temporary; CustLedgEntryNo: Integer)
var
DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeInsertCustTempRevertTransNo(TempTransactionNoInteger, CustLedgEntryNo, IsHandled);
if IsHandled then
exit;
DetailedCustLedgEntry.Get(CustLedgEntryNo);
if DetailedCustLedgEntry."Transaction No." <> 0 then begin
TempTransactionNoInteger.Number := DetailedCustLedgEntry."Transaction No.";
if TempTransactionNoInteger.Insert() then;
end;
end;
local procedure InsertVendTempRevertTransNo(var TempTransactionNoInteger: Record "Integer" temporary; VendLedgEntryNo: Integer)
var
DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeInsertVendTempRevertTransNo(TempTransactionNoInteger, VendLedgEntryNo, IsHandled);
if IsHandled then
exit;
DetailedVendorLedgEntry.Get(VendLedgEntryNo);
if DetailedVendorLedgEntry."Transaction No." <> 0 then begin
TempTransactionNoInteger.Number := DetailedVendorLedgEntry."Transaction No.";
if TempTransactionNoInteger.Insert() then;
end;
end;
local procedure InsertEmplTempRevertTransNo(var TempTransactionNoInteger: Record "Integer" temporary; EmployeeLedgEntryNo: Integer)
var
DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry";
begin
DetailedEmployeeLedgerEntry.Get(EmployeeLedgEntryNo);
if DetailedEmployeeLedgerEntry."Transaction No." <> 0 then begin
TempTransactionNoInteger.Number := DetailedEmployeeLedgerEntry."Transaction No.";
if TempTransactionNoInteger.Insert() then;
end;
end;
local procedure InsertTempRevertTransactionNoUnappliedEmployeeEntries(var TempTransactionNoInteger: Record "Integer" temporary; var DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry")
begin
DetailedEmployeeLedgerEntry.SetRange(Unapplied, true);
if DetailedEmployeeLedgerEntry.FindSet() then
repeat
InsertEmplTempRevertTransNo(TempTransactionNoInteger, DetailedEmployeeLedgerEntry."Unapplied by Entry No.");
until DetailedEmployeeLedgerEntry.Next() = 0;
DetailedEmployeeLedgerEntry.SetRange(Unapplied);
end;
/// <summary>
/// Integration event raised after calculating the caption for a reversal entry, allowing customization of the display text.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record for which the caption is being calculated</param>
/// <param name="NewCaption">Caption text that can be modified by subscribers</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCaption(ReversalEntry: Record "Reversal Entry"; var NewCaption: Text)
begin
end;
/// <summary>
/// Integration event raised after completing entry validation checks, allowing custom validation logic.
/// </summary>
/// <param name="MaxPostingDate">Maximum posting date found during validation</param>
/// <param name="ReversalEntry">Reversal entry record being validated</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckEntries(var MaxPostingDate: Date; var ReversalEntry: Record "Reversal Entry")
begin
end;
/// <summary>
/// Integration event raised after validating bank account ledger entries for reversal eligibility.
/// </summary>
/// <param name="BankAccount">Bank account master record</param>
/// <param name="BankAccountLedgerEntry">Bank account ledger entry being validated</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckBankAcc(BankAccount: Record "Bank Account"; BankAccountLedgerEntry: Record "Bank Account Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after validating G/L account settings for reversal operations.
/// </summary>
/// <param name="GLAccount">G/L account record being validated</param>
/// <param name="GLEntry">G/L entry being checked for reversal</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckGLAcc(var GLAccount: Record "G/L Account"; GLEntry: Record "G/L Entry")
begin
end;
/// <summary>
/// Integration event raised after validating customer ledger entries for reversal eligibility.
/// </summary>
/// <param name="Customer">Customer master record</param>
/// <param name="CustLedgerEntry">Customer ledger entry being validated</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckCust(Customer: Record Customer; CustLedgerEntry: Record "Cust. Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after validating vendor ledger entries for reversal eligibility.
/// </summary>
/// <param name="Vendor">Vendor master record</param>
/// <param name="VendorLedgerEntry">Vendor ledger entry being validated</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckVend(Vendor: Record Vendor; VendorLedgerEntry: Record "Vendor Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after validating employee ledger entries for reversal eligibility.
/// </summary>
/// <param name="Employee">Employee master record</param>
/// <param name="EmployeeLedgerEntry">Employee ledger entry being validated</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckEmpl(Employee: Record Employee; EmployeeLedgerEntry: Record "Employee Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after validating fixed asset ledger entries for reversal eligibility.
/// </summary>
/// <param name="FixedAsset">Fixed asset master record</param>
/// <param name="FALedgerEntry">Fixed asset ledger entry being validated</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFA(FixedAsset: Record "Fixed Asset"; FALedgerEntry: Record "FA Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after validating maintenance ledger entries for reversal eligibility.
/// </summary>
/// <param name="FixedAsset">Fixed asset master record</param>
/// <param name="MaintenanceLedgerEntry">Maintenance ledger entry being validated</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckMaintenance(FixedAsset: Record "Fixed Asset"; MaintenanceLedgerEntry: Record "Maintenance Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after validating VAT entries for reversal eligibility.
/// </summary>
/// <param name="VATEntry">VAT entry being validated</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckVAT(var VATEntry: Record "VAT Entry")
begin
end;
/// <summary>
/// Integration event raised after validating detailed customer ledger entries for reversal consistency.
/// </summary>
/// <param name="DetailedCustLedgEntry">Detailed customer ledger entry being validated</param>
/// <param name="CustLedgerEntry">Related customer ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckDtldCustLedgEntry(DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; CustLedgerEntry: Record "Cust. Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after validating detailed vendor ledger entries for reversal consistency.
/// </summary>
/// <param name="DetailedVendorLedgEntry">Detailed vendor ledger entry being validated</param>
/// <param name="VendorLedgerEntry">Related vendor ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckDtldVendLedgEntry(DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; VendorLedgerEntry: Record "Vendor Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after validating detailed employee ledger entries for reversal consistency.
/// </summary>
/// <param name="DetailedEmployeeLedgerEntry">Detailed employee ledger entry being validated</param>
/// <param name="EmployeeLedgerEntry">Related employee ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckDtldEmplLedgEntry(DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry"; EmployeeLedgerEntry: Record "Employee Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after copying field values from a bank account ledger entry to a reversal entry.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record that was populated</param>
/// <param name="BankAccLedgEntry">Source bank account ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromBankAccLedgEntry(var ReversalEntry: Record "Reversal Entry"; BankAccLedgEntry: Record "Bank Account Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after copying field values from a customer ledger entry to a reversal entry.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record that was populated</param>
/// <param name="CustLedgerEntry">Source customer ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromCustLedgEntry(var ReversalEntry: Record "Reversal Entry"; CustLedgerEntry: Record "Cust. Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after copying field values from a fixed asset ledger entry to a reversal entry.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record that was populated</param>
/// <param name="FALedgerEntry">Source fixed asset ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromFALedgEntry(var ReversalEntry: Record "Reversal Entry"; FALedgerEntry: Record "FA Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after copying field values from a G/L entry to a reversal entry.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record that was populated</param>
/// <param name="GLEntry">Source G/L entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromGLEntry(var ReversalEntry: Record "Reversal Entry"; GLEntry: Record "G/L Entry")
begin
end;
/// <summary>
/// Integration event raised after copying field values from a maintenance ledger entry to a reversal entry.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record that was populated</param>
/// <param name="MaintenanceLedgerEntry">Source maintenance ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromMaintenanceEntry(var ReversalEntry: Record "Reversal Entry"; MaintenanceLedgerEntry: Record "Maintenance Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after copying field values from a VAT entry to a reversal entry.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record that was populated</param>
/// <param name="VATEntry">Source VAT entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromVATEntry(var ReversalEntry: Record "Reversal Entry"; VATEntry: Record "VAT Entry")
begin
end;
/// <summary>
/// Integration event raised after copying field values from a vendor ledger entry to a reversal entry.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record that was populated</param>
/// <param name="VendorLedgerEntry">Source vendor ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromVendLedgEntry(var ReversalEntry: Record "Reversal Entry"; VendorLedgerEntry: Record "Vendor Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after copying field values from an employee ledger entry to a reversal entry.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record that was populated</param>
/// <param name="EmployeeLedgerEntry">Source employee ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromEmplLedgEntry(var ReversalEntry: Record "Reversal Entry"; EmployeeLedgerEntry: Record "Employee Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after inserting a reversal entry from a bank account ledger entry.
/// </summary>
/// <param name="TempRevertTransactionNo">Temporary table storing transaction numbers for reversal processing</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="NextLineNo">Next available line number for reversal entries</param>
/// <param name="TempReversalEntry">Temporary reversal entry record being created</param>
/// <param name="BankAccLedgEntry">Source bank account ledger entry being reversed</param>
[IntegrationEvent(true, false)]
local procedure OnAfterInsertFromBankAccLedgEntry(var TempRevertTransactionNo: Record "Integer"; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer; var TempReversalEntry: Record "Reversal Entry" temporary; var BankAccLedgEntry: Record "Bank Account Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after inserting a reversal entry from a customer ledger entry.
/// </summary>
/// <param name="TempRevertTransactionNo">Temporary table storing transaction numbers for reversal processing</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="NextLineNo">Next available line number for reversal entries</param>
/// <param name="TempReversalEntry">Temporary reversal entry record being created</param>
/// <param name="CustLedgEntry">Source customer ledger entry being reversed</param>
[IntegrationEvent(true, false)]
local procedure OnAfterInsertFromCustLedgEntry(var TempRevertTransactionNo: Record "Integer"; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer; var TempReversalEntry: Record "Reversal Entry" temporary; var CustLedgEntry: Record "Cust. Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after inserting a reversal entry from an employee ledger entry.
/// </summary>
/// <param name="TempRevertTransactionNo">Temporary table storing transaction numbers for reversal processing</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="NextLineNo">Next available line number for reversal entries</param>
/// <param name="TempReversalEntry">Temporary reversal entry record being created</param>
/// <param name="EmplLedgEntry">Source employee ledger entry being reversed</param>
[IntegrationEvent(true, false)]
local procedure OnAfterInsertFromEmplLedgEntry(var TempRevertTransactionNo: Record "Integer"; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer; var TempReversalEntry: Record "Reversal Entry" temporary; var EmplLedgEntry: Record "Employee Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after inserting a reversal entry from a fixed asset ledger entry.
/// </summary>
/// <param name="TempRevertTransactionNo">Temporary table storing transaction numbers for reversal processing</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="NextLineNo">Next available line number for reversal entries</param>
/// <param name="TempReversalEntry">Temporary reversal entry record being created</param>
/// <param name="FALedgerEntry">Source fixed asset ledger entry being reversed</param>
[IntegrationEvent(true, false)]
local procedure OnAfterInsertFromFALedgEntry(var TempRevertTransactionNo: Record "Integer"; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer; var TempReversalEntry: Record "Reversal Entry" temporary; var FALedgerEntry: Record "FA Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after inserting a reversal entry from a general ledger entry.
/// </summary>
/// <param name="TempRevertTransactionNo">Temporary table storing transaction numbers for reversal processing</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="NextLineNo">Next available line number for reversal entries</param>
/// <param name="TempReversalEntry">Temporary reversal entry record being created</param>
/// <param name="GLEntry">Source general ledger entry being reversed</param>
[IntegrationEvent(true, false)]
local procedure OnAfterInsertFromGLEntry(var TempRevertTransactionNo: Record "Integer"; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer; var TempReversalEntry: Record "Reversal Entry" temporary; var GLEntry: Record "G/L Entry")
begin
end;
/// <summary>
/// Integration event raised after inserting a reversal entry from a maintenance ledger entry.
/// </summary>
/// <param name="TempRevertTransactionNo">Temporary table storing transaction numbers for reversal processing</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="NextLineNo">Next available line number for reversal entries</param>
/// <param name="TempReversalEntry">Temporary reversal entry record being created</param>
/// <param name="MaintenanceLedgEntry">Source maintenance ledger entry being reversed</param>
[IntegrationEvent(true, false)]
local procedure OnAfterInsertFromMaintenanceLedgEntry(var TempRevertTransactionNo: Record "Integer"; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer; var TempReversalEntry: Record "Reversal Entry" temporary; var MaintenanceLedgEntry: Record "Maintenance Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after completing the insertion of a reversal entry record.
/// </summary>
/// <param name="TempRevertTransactionNo">Temporary table storing transaction numbers for reversal processing</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="NextLineNo">Next available line number for reversal entries</param>
/// <param name="TempReversalEntry">Temporary reversal entry record that was created</param>
[IntegrationEvent(true, false)]
local procedure OnAfterInsertReversalEntry(var TempRevertTransactionNo: Record "Integer"; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer; var TempReversalEntry: Record "Reversal Entry" temporary)
begin
end;
/// <summary>
/// Integration event raised after inserting a reversal entry from a VAT entry.
/// </summary>
/// <param name="TempRevertTransactionNo">Temporary table storing transaction numbers for reversal processing</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="NextLineNo">Next available line number for reversal entries</param>
/// <param name="TempReversalEntry">Temporary reversal entry record being created</param>
/// <param name="VATEntry">Source VAT entry being reversed</param>
[IntegrationEvent(true, false)]
local procedure OnAfterInsertFromVATEntry(var TempRevertTransactionNo: Record "Integer"; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer; var TempReversalEntry: Record "Reversal Entry" temporary; var VATEntry: Record "VAT Entry")
begin
end;
/// <summary>
/// Integration event raised after inserting a reversal entry from a vendor ledger entry.
/// </summary>
/// <param name="TempRevertTransactionNo">Temporary table storing transaction numbers for reversal processing</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="NextLineNo">Next available line number for reversal entries</param>
/// <param name="TempReversalEntry">Temporary reversal entry record being created</param>
/// <param name="VendLedgEntry">Source vendor ledger entry being reversed</param>
[IntegrationEvent(true, false)]
local procedure OnAfterInsertFromVendLedgEntry(var TempRevertTransactionNo: Record "Integer"; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer; var TempReversalEntry: Record "Reversal Entry" temporary; var VendLedgEntry: Record "Vendor Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after completing the reversal of entries for a transaction or register.
/// </summary>
/// <param name="Number">Transaction or register number that was reversed</param>
/// <param name="RevType">Type of reversal operation that was completed</param>
/// <param name="HideDialog">Indicates whether dialog messages were suppressed during reversal</param>
[IntegrationEvent(false, false)]
local procedure OnAfterReverseEntries(Number: Integer; RevType: Integer; HideDialog: Boolean)
begin
end;
/// <summary>
/// Integration event raised after setting filters for reversal entries based on transaction or register.
/// </summary>
/// <param name="Number">Transaction or register number used for filtering</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="GLRegister">G/L register record used for filtering when reversing by register</param>
/// <param name="ReversalEntry">Reversal entry record with applied filters</param>
[IntegrationEvent(false, false)]
local procedure OnAfterSetReverseFilter(Number: Integer; RevType: Option Transaction,Register; GLRegister: Record "G/L Register"; var ReversalEntry: Record "Reversal Entry")
begin
end;
/// <summary>
/// Integration event raised before performing entry validation checks for reversal.
/// </summary>
/// <param name="ReversalEntry">Reversal entry being validated</param>
/// <param name="TableID">Table ID of the ledger entry being checked</param>
/// <param name="SkipCheck">Set to true to skip standard validation checks</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckEntries(ReversalEntry: Record "Reversal Entry"; TableID: Integer; var SkipCheck: Boolean)
begin
end;
/// <summary>
/// Integration event raised before validating employee ledger entries for reversal.
/// </summary>
/// <param name="EmployeeLedgerEntry">Employee ledger entry being validated for reversal</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckEmpl(var EmployeeLedgerEntry: Record "Employee Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before validating fixed asset ledger entries for reversal.
/// </summary>
/// <param name="FALedgerEntry">Fixed asset ledger entry being validated for reversal</param>
/// <param name="IsHandled">Set to true to skip standard FA validation logic</param>
[IntegrationEvent(true, false)]
local procedure OnBeforeCheckFA(var FALedgerEntry: Record "FA Ledger Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before validating fixed asset posting date for reversal.
/// </summary>
/// <param name="FAPostingDate">FA posting date being validated</param>
/// <param name="Caption">Caption for error messages</param>
/// <param name="EntryNo">Entry number being validated</param>
/// <param name="IsHandled">Set to true to skip standard posting date validation</param>
/// <param name="ReversalEntry">Current reversal entry record</param>
/// <param name="MaxPostingDate">Maximum allowed posting date</param>
/// <param name="AllowPostingFrom">Earliest allowed posting date</param>
/// <param name="AllowPostingto">Latest allowed posting date</param>
/// <param name="xReversalEntry">Previous reversal entry record state</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckFAPostingDate(FAPostingDate: Date; Caption: Text[50]; EntryNo: Integer; var IsHandled: Boolean; var ReversalEntry: Record "Reversal Entry"; var MaxPostingDate: Date; var AllowPostingFrom: Date; var AllowPostingto: Date; var xReversalEntry: Record "Reversal Entry")
begin
end;
/// <summary>
/// Integration event raised before validating maintenance ledger entries for reversal.
/// </summary>
/// <param name="MaintenanceLedgerEntry">Maintenance ledger entry being validated for reversal</param>
[IntegrationEvent(true, false)]
local procedure OnBeforeCheckMaintenance(var MaintenanceLedgerEntry: Record "Maintenance Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before validating G/L account settings for reversal.
/// </summary>
/// <param name="GLEntry">G/L entry being validated for reversal</param>
[IntegrationEvent(true, false)]
local procedure OnBeforeCheckGLAcc(var GLEntry: Record "G/L Entry")
begin
end;
/// <summary>
/// Integration event raised before validating G/L entry for reversal.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record being validated</param>
/// <param name="GLEntry">G/L entry being validated for reversal</param>
/// <param name="IsHandled">Set to true to skip standard G/L entry validation</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckGLEntry(var ReversalEntry: Record "Reversal Entry"; GLEntry: Record "G/L Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before validating register entries for reversal.
/// </summary>
/// <param name="RegisterNo">G/L register number being validated</param>
/// <param name="IsHandled">Set to true to skip standard register validation</param>
/// <param name="ReversalEntry">Reversal entry record being processed</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckRegister(RegisterNo: Integer; var IsHandled: Boolean; var ReversalEntry: Record "Reversal Entry")
begin
end;
/// <summary>
/// Integration event raised before inserting a new reversal entry record.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record being inserted</param>
/// <param name="Number">Transaction or register number for the reversal</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="IsHandled">Set to true to skip standard insertion logic</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeInsertReversalEntry(var ReversalEntry: Record "Reversal Entry"; Number: Integer; RevType: Option Transaction,Register; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before starting the reversal process for entries.
/// </summary>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation being performed</param>
/// <param name="IsHandled">Set to true to skip standard reversal processing</param>
/// <param name="HideDialog">Indicates whether to suppress dialog messages</param>
/// <param name="ReversalEntry">Reversal entry record being processed</param>
/// <param name="HideWarningDialogs">Indicates whether to suppress warning dialogs</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeReverseEntries(Number: Integer; RevType: Integer; var IsHandled: Boolean; HideDialog: Boolean; var ReversalEntry: Record "Reversal Entry"; var HideWarningDialogs: Boolean)
begin
end;
/// <summary>
/// Integration event raised before inserting temporary reversal entry from customer ledger entry.
/// </summary>
/// <param name="TempReversalEntry">Temporary reversal entry being inserted</param>
/// <param name="CustLedgEntry">Source customer ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromCustLedgEntryOnBeforeTempReversalEntryInsert(var TempReversalEntry: Record "Reversal Entry" temporary; CustLedgEntry: Record "Cust. Ledger Entry");
begin
end;
/// <summary>
/// Integration event raised before clearing temporary reversal entry in G/L entry processing.
/// </summary>
/// <param name="GLEntry">G/L entry being processed for reversal</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromGLEntryOnBeforeClearTempReversalEntry(GLEntry: Record "G/L Entry");
begin
end;
/// <summary>
/// Integration event raised before inserting temporary reversal entry from G/L entry.
/// </summary>
/// <param name="TempReversalEntry">Temporary reversal entry being inserted</param>
/// <param name="GLEntry">Source G/L entry</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="TempRevertTransactionNoRecordInteger">Temporary transaction number record</param>
/// <param name="ReversalEntry">Current reversal entry context</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromGLEntryOnBeforeTempReversalEntryInsert(var TempReversalEntry: Record "Reversal Entry" temporary; GLEntry: Record "G/L Entry"; RevType: Option Transaction,Register; var TempRevertTransactionNoRecordInteger: Record "Integer" temporary; ReversalEntry: Record "Reversal Entry");
begin
end;
/// <summary>
/// Integration event raised before inserting temporary reversal entry from vendor ledger entry.
/// </summary>
/// <param name="TempReversalEntry">Temporary reversal entry being inserted</param>
/// <param name="VendorLedgerEntry">Source vendor ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromVendLedgEntryOnBeforeTempReversalEntryInsert(var TempReversalEntry: Record "Reversal Entry" temporary; VendorLedgerEntry: Record "Vendor Ledger Entry");
begin
end;
/// <summary>
/// Integration event raised before generating caption text for reversal entries.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record for caption generation</param>
/// <param name="Result">Variable to store the generated caption text</param>
/// <param name="IsHandled">Set to true to skip standard caption generation</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCaption(ReversalEntry: Record "Reversal Entry"; var Result: Text; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before validating VAT entries for reversal.
/// </summary>
/// <param name="VATEntry">VAT entry being validated for reversal</param>
/// <param name="IsHandled">Set to true to skip standard VAT validation</param>
[IntegrationEvent(true, false)]
local procedure OnBeforeCheckVAT(var VATEntry: Record "VAT Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before validating bank account ledger entries for reversal.
/// </summary>
/// <param name="BankAccLedgEntry">Bank account ledger entry being validated for reversal</param>
/// <param name="IsHandled">Set to true to skip standard bank account validation</param>
/// <param name="SkipBankAccountLedgerEntryOpenCheck">Set to true to skip the check that the entry must be open</param>
/// <param name="SkipBankAccountLedgerEntryStatementNoCheck">Set to true to skip the check that the entry has no statement number</param>
[IntegrationEvent(true, false)]
local procedure OnBeforeCheckBankAcc(var BankAccLedgEntry: Record "Bank Account Ledger Entry"; var IsHandled: Boolean; var SkipBankAccountLedgerEntryOpenCheck: Boolean; var SkipBankAccountLedgerEntryStatementNoCheck: Boolean)
begin
end;
/// <summary>
/// Integration event raised before validating vendor ledger entries for reversal.
/// </summary>
/// <param name="VendLedgEntry">Vendor ledger entry being validated for reversal</param>
[IntegrationEvent(true, false)]
local procedure OnBeforeCheckVend(var VendLedgEntry: Record "Vendor Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before validating customer ledger entries for reversal.
/// </summary>
/// <param name="CustLedgEntry">Customer ledger entry being validated for reversal</param>
[IntegrationEvent(true, false)]
local procedure OnBeforeCheckCust(var CustLedgEntry: Record "Cust. Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before testing G/L account fields during reversal validation.
/// </summary>
/// <param name="GLAcc">G/L account being tested</param>
/// <param name="GLEntry">G/L entry associated with the account</param>
/// <param name="IsHandled">Set to true to skip standard field testing</param>
[IntegrationEvent(false, false)]
local procedure OnCheckGLAccOnBeforeTestFields(GLAcc: Record "G/L Account"; GLEntry: Record "G/L Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before validating posting dates for reversal entries.
/// </summary>
/// <param name="PostingDate">Posting date being validated</param>
/// <param name="Caption">Caption for error messages</param>
/// <param name="EntryNo">Entry number being validated</param>
/// <param name="IsHandled">Set to true to skip standard posting date validation</param>
/// <param name="ReversalEntry">Current reversal entry record</param>
/// <param name="MaxPostingDate">Maximum allowed posting date</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckPostingDate(PostingDate: Date; Caption: Text[50]; EntryNo: Integer; var IsHandled: Boolean; var ReversalEntry: Record "Reversal Entry"; var MaxPostingDate: Date)
begin
end;
/// <summary>
/// Integration event raised before validating detailed customer ledger entries for reversal.
/// </summary>
/// <param name="CustLedgEntry">Customer ledger entry with related detailed entries</param>
/// <param name="IsHandled">Set to true to skip standard detailed entry validation</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckDtldCustLedgEntry(CustLedgEntry: Record "Cust. Ledger Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before validating detailed vendor ledger entries for reversal.
/// </summary>
/// <param name="VendLedgEntry">Vendor ledger entry with related detailed entries</param>
/// <param name="IsHandled">Set to true to skip standard detailed entry validation</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCCheckDtldVendLedgEntry(VendLedgEntry: Record "Vendor Ledger Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before checking same transaction in vendor ledger entry processing.
/// </summary>
/// <param name="VendLedgEntry">Vendor ledger entry being processed</param>
/// <param name="DtldVendLedgEntry">Detailed vendor ledger entry for transaction check</param>
/// <param name="IsHandled">Set to true to skip standard same transaction validation</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromVendLedgEntryOnBeforeCheckSameTransaction(VendLedgEntry: Record "Vendor Ledger Entry"; var DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before checking same transaction in customer ledger entry processing.
/// </summary>
/// <param name="CustLedgEntry">Customer ledger entry being processed</param>
/// <param name="DtldCustLedgEntry">Detailed customer ledger entry for transaction check</param>
/// <param name="IsHandled">Set to true to skip standard same transaction validation</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromCustLedgEntryOnBeforeCheckSameTransaction(CustLedgEntry: Record "Cust. Ledger Entry"; var DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised after inserting reversal entry during reverse entries processing.
/// </summary>
/// <param name="TempReversalEntry">Temporary reversal entry that was inserted</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
[IntegrationEvent(false, false)]
local procedure OnReverseEntriesOnAfterInsertReversalEntry(var TempReversalEntry: Record "Reversal Entry" temporary; Number: Integer; RevType: Option Transaction,Register)
begin
end;
/// <summary>
/// Integration event raised before setting filters for reversal processing across all ledger entry types.
/// </summary>
/// <param name="Number">Transaction or register number for filtering</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="GLEntry">G/L entry record for filtering</param>
/// <param name="CustLedgerEntry">Customer ledger entry record for filtering</param>
/// <param name="VendLedgerEntry">Vendor ledger entry record for filtering</param>
/// <param name="EmployeeLedgerEntry">Employee ledger entry record for filtering</param>
/// <param name="BankAccountLedgerEntry">Bank account ledger entry record for filtering</param>
/// <param name="VATEntry">VAT entry record for filtering</param>
/// <param name="FALedgerEntry">Fixed asset ledger entry record for filtering</param>
/// <param name="MaintenanceLedgerEntry">Maintenance ledger entry record for filtering</param>
/// <param name="GLRegister">G/L register record for filtering</param>
/// <param name="ReversalEntry">Reversal entry record for filtering</param>
/// <param name="IsHandled">Set to true to skip standard filter setting</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeSetReverseFilter(Number: Integer; RevType: Option Transaction,Register; var GLEntry: Record "G/L Entry"; var CustLedgerEntry: Record "Cust. Ledger Entry"; var VendLedgerEntry: Record "Vendor Ledger Entry"; var EmployeeLedgerEntry: Record "Employee Ledger Entry"; var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; var VATEntry: Record "VAT Entry"; var FALedgerEntry: Record "FA Ledger Entry"; var MaintenanceLedgerEntry: Record "Maintenance Ledger Entry"; var GLRegister: Record "G/L Register"; var ReversalEntry: Record "Reversal Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised at the start of bank account ledger entry processing loop.
/// </summary>
/// <param name="BankAccountLedgerEntry">Bank account ledger entry being processed</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromBankAccLedgEntryOnStartRepeatBankAccLedgEntry(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before inserting reversal entries from fixed asset ledger entries.
/// </summary>
/// <param name="TempRevertTransactionNoRecordInteger">Temporary transaction number record</param>
/// <param name="Number">Transaction or register number being reversed</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="NextLineNo">Next available line number for reversal entries</param>
/// <param name="TempReversalEntry">Temporary reversal entry being processed</param>
/// <param name="FALedgerEntry">Fixed asset ledger entry being processed</param>
/// <param name="IsHandled">Set to true to skip standard FA entry processing</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeInsertFromFALedgEntry(var TempRevertTransactionNoRecordInteger: Record "Integer"; Number: Integer; RevType: Option Transaction,Register; var NextLineNo: Integer; var TempReversalEntry: Record "Reversal Entry" temporary; var FALedgerEntry: Record "FA Ledger Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised after setting VAT entry range filters during reversal processing.
/// </summary>
/// <param name="VATEntry">VAT entry with applied filters</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="TempRevertTransactionNoRecordInteger">Temporary transaction number record</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromVATEntryOnAfterVATEntrySetRange(var VATEntry: Record "VAT Entry"; RevType: Option Transaction,Register; var TempRevertTransactionNoRecordInteger: Record "Integer" temporary)
begin
end;
/// <summary>
/// Integration event raised at the start of VAT entry processing loop during reversal.
/// </summary>
/// <param name="VATEntry">VAT entry being processed in the loop</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromVATEntryOnStartRepeatVATEntry(var VATEntry: Record "VAT Entry")
begin
end;
/// <summary>
/// Integration event raised before inserting temporary reversal entry from VAT entry.
/// </summary>
/// <param name="TempReversalEntry">Temporary reversal entry being inserted</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="TempRevertTransactionNo">Temporary transaction number record</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromVATEntryOnBeforeTempReversalEntryInsert(var TempReversalEntry: Record "Reversal Entry" temporary; RevType: Option Transaction,Register; var TempRevertTransactionNo: Record "Integer" temporary)
begin
end;
/// <summary>
/// Integration event raised after setting G/L entry range filters during reversal processing.
/// </summary>
/// <param name="GLEntry">G/L entry with applied filters</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="TempRevertTransactionNoRecordInteger">Temporary transaction number record</param>
[IntegrationEvent(false, false)]
local procedure OnInsertFromGLEntryOnAfterGLEntrySetRange(var GLEntry: Record "G/L Entry"; RevType: Option Transaction,Register; var TempRevertTransactionNoRecordInteger: Record "Integer" temporary)
begin
end;
/// <summary>
/// Integration event raised before inserting customer temporary revert transaction number.
/// </summary>
/// <param name="TempRevertTransactionNoRecordInteger">Temporary transaction number record being inserted</param>
/// <param name="CustLedgEntryNo">Customer ledger entry number for transaction tracking</param>
/// <param name="IsHandled">Set to true to skip standard insertion logic</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeInsertCustTempRevertTransNo(var TempRevertTransactionNoRecordInteger: Record "Integer" temporary; CustLedgEntryNo: Integer; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before inserting vendor temporary revert transaction number.
/// </summary>
/// <param name="TempRevertTransactionNoRecordInteger">Temporary transaction number record being inserted</param>
/// <param name="VendLedgEntryNo">Vendor ledger entry number for transaction tracking</param>
/// <param name="IsHandled">Set to true to skip standard insertion logic</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeInsertVendTempRevertTransNo(var TempRevertTransactionNoRecordInteger: Record "Integer" temporary; VendLedgEntryNo: Integer; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before verifying reversal entries for processing validity.
/// </summary>
/// <param name="ReversalEntry2">Reversal entry record being verified</param>
/// <param name="Number">Transaction or register number being verified</param>
/// <param name="RevType">Type of reversal operation - Transaction or Register</param>
/// <param name="IsHandled">Set to true to skip standard verification logic</param>
/// <param name="Result">Variable to store verification result</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeVerifyReversalEntries(var ReversalEntry2: Record "Reversal Entry"; Number: Integer; RevType: Option Transaction,Register; var IsHandled: Boolean; var Result: Boolean)
begin
end;
}