Codeunit 17 Gen. Jnl.-Post Reverse, source in 29
Source29
src/Layers/W1/BaseApp/Finance/GeneralLedger/Reversal/GenJnlPostReverse.Codeunit.al1538 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.CRM.Team;
using Microsoft.Finance.Analysis;
using Microsoft.Finance.Dimension;
using Microsoft.Finance.GeneralLedger.Account;
using Microsoft.Finance.GeneralLedger.Journal;
using Microsoft.Finance.GeneralLedger.Ledger;
using Microsoft.Finance.GeneralLedger.Posting;
using Microsoft.Finance.SpendRequest;
using Microsoft.Finance.VAT.Calculation;
using Microsoft.Finance.VAT.Ledger;
using Microsoft.FixedAssets.Ledger;
using Microsoft.FixedAssets.Maintenance;
using Microsoft.Foundation.AuditCodes;
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.Utilities;
/// <summary>
/// Handles reversal of posted general journal entries and related ledger entries.
/// Provides comprehensive reversal functionality for G/L, customer, vendor, employee, and bank account transactions.
/// </summary>
/// <remarks>
/// Core reversal engine that creates offsetting entries to reverse the effects of posted transactions.
/// Supports reversal of entire registers or individual transactions with proper audit trail maintenance.
/// Integrates with G/L, customer ledger, vendor ledger, employee ledger, bank account ledger, and VAT systems.
/// </remarks>
codeunit 17 "Gen. Jnl.-Post Reverse"
{
Permissions = TableData "G/L Entry" = rm,
TableData "Cust. Ledger Entry" = rimd,
TableData "Vendor Ledger Entry" = rimd,
TableData "G/L Register" = rm,
TableData "G/L Transaction" = rm,
TableData "G/L Entry - VAT Entry Link" = rimd,
TableData "VAT Entry" = rimd,
TableData "Bank Account Ledger Entry" = rimd,
TableData "Check Ledger Entry" = rimd,
TableData "Detailed Cust. Ledg. Entry" = rimd,
TableData "Detailed Vendor Ledg. Entry" = rimd,
TableData "Employee Ledger Entry" = rimd,
TableData "Spend Request to G/L Link" = rimd,
TableData "Detailed Employee Ledger Entry" = ri;
TableNo = "Gen. Journal Line";
trigger OnRun()
begin
end;
var
GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line";
NonDeductibleVAT: Codeunit "Non-Deductible VAT";
ReversalMismatchErr: Label 'Reversal found a %1 without a matching general ledger entry.', Comment = '%1 - table caption';
CannotReverseErr: Label 'You cannot reverse the transaction, because it has already been reversed.';
DimCombBlockedErr: Label 'The combination of dimensions used in general ledger entry %1 is blocked. %2.', Comment = '%1 - entry no, %2 - error text';
/// <summary>
/// Executes the reversal process for specified entries and creates offsetting transactions.
/// Handles complete reversal workflow including G/L entries, subsidiary ledgers, and VAT entries.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record containing entries to be reversed</param>
/// <param name="ReversalEntry2">Working copy of reversal entries for processing</param>
/// <remarks>
/// Creates offsetting entries with opposite amounts and links them to original entries.
/// Updates reversal flags and maintains audit trail for all affected ledger entries.
/// Supports both register-based and transaction-based reversal modes.
/// </remarks>
procedure Reverse(var ReversalEntry: Record "Reversal Entry"; var ReversalEntry2: Record "Reversal Entry")
var
SourceCodeSetup: Record "Source Code Setup";
GLEntry2: Record "G/L Entry";
GLRegister: Record "G/L Register";
GLRegister2: Record "G/L Register";
GenJournalLine: Record "Gen. Journal Line";
CustLedgerEntry: Record "Cust. Ledger Entry";
TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary;
VendorLedgerEntry: Record "Vendor Ledger Entry";
TempVendorLedgerEntry: Record "Vendor Ledger Entry" temporary;
EmployeeLedgerEntry: Record "Employee Ledger Entry";
TempEmployeeLedgerEntry: Record "Employee Ledger Entry" temporary;
BankAccountLedgerEntry: Record "Bank Account Ledger Entry";
TempBankAccountLedgerEntry: Record "Bank Account Ledger Entry" temporary;
VATEntry: Record "VAT Entry";
FALedgerEntry: Record "FA Ledger Entry";
MaintenanceLedgerEntry: Record "Maintenance Ledger Entry";
TempTransactionNoInteger: Record "Integer" temporary;
FAInsertLedgerEntry: Codeunit "FA Insert Ledger Entry";
UpdateAnalysisView: Codeunit "Update Analysis View";
NextDtldCustLedgEntryEntryNo: Integer;
NextDtldVendLedgEntryEntryNo: Integer;
NextDtldEmplLedgEntryNo: Integer;
TransactionKey: Integer;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeReverse(ReversalEntry, ReversalEntry2, IsHandled);
if IsHandled then
exit;
SourceCodeSetup.Get();
if ReversalEntry2."Reversal Type" = ReversalEntry2."Reversal Type"::Register then
GLRegister2."No." := ReversalEntry2."G/L Register No.";
ReversalEntry.CopyReverseFilters(
GLEntry2, CustLedgerEntry, VendorLedgerEntry, BankAccountLedgerEntry, VATEntry, FALedgerEntry, MaintenanceLedgerEntry, EmployeeLedgerEntry);
if ReversalEntry2."Reversal Type" = ReversalEntry2."Reversal Type"::Transaction then begin
GLRegister2."No." := GetRegisterNoForTransactionReversal(ReversalEntry2);
if ReversalEntry2.FindFirst() then
repeat
TempTransactionNoInteger.Number := ReversalEntry2."Transaction No.";
if TempTransactionNoInteger.Insert() then;
until ReversalEntry2.Next() = 0;
end;
OnReverseOnBeforeGetTransactionKey(ReversalEntry2, TempTransactionNoInteger);
TransactionKey := GetTransactionKey();
SaveReversalEntries(ReversalEntry2, TransactionKey);
GenJournalLine.Init();
GenJournalLine."Source Code" := SourceCodeSetup.Reversal;
GenJournalLine."Journal Template Name" := GLEntry2."Journal Templ. Name";
OnReverseOnBeforeStartPosting(GenJournalLine, ReversalEntry2, GLEntry2, GenJnlPostLine);
if GenJnlPostLine.GetNextEntryNo() = 0 then
GenJnlPostLine.StartPosting(GenJournalLine)
else
GenJnlPostLine.ContinuePosting(GenJournalLine);
OnReverseOnAfterStartPosting(GenJournalLine, GenJnlPostLine, GLRegister, GLRegister2);
GenJnlPostLine.SetGLRegReverse(GLRegister);
CopyCustLedgEntry(CustLedgerEntry, TempCustLedgerEntry);
CopyVendLedgEntry(VendorLedgerEntry, TempVendorLedgerEntry);
CopyEmplLedgEntry(EmployeeLedgerEntry, TempEmployeeLedgerEntry);
CopyBankAccLedgEntry(BankAccountLedgerEntry, TempBankAccountLedgerEntry);
if TempTransactionNoInteger.FindSet() then;
repeat
if ReversalEntry2."Reversal Type" = ReversalEntry2."Reversal Type"::Transaction then
GLEntry2.SetRange("Transaction No.", TempTransactionNoInteger.Number);
OnReverseOnBeforeReverseGLEntry(ReversalEntry2, GenJnlPostLine, GenJournalLine, TempTransactionNoInteger, GLEntry2, GLRegister);
ReverseGLEntry(
GLEntry2, GenJournalLine, GLRegister,
TempCustLedgerEntry, TempVendorLedgerEntry, TempEmployeeLedgerEntry, TempBankAccountLedgerEntry,
NextDtldCustLedgEntryEntryNo, NextDtldVendLedgEntryEntryNo, NextDtldEmplLedgEntryNo, FAInsertLedgerEntry);
until TempTransactionNoInteger.Next() = 0;
IsHandled := false;
OnReverseOnBeforeCheckFAReverseEntry(FALedgerEntry, FAInsertLedgerEntry, ReversalEntry2, GenJnlPostLine, IsHandled);
if not IsHandled then
if FALedgerEntry.FindSet() then
repeat
FAInsertLedgerEntry.CheckFAReverseEntry(FALedgerEntry)
until FALedgerEntry.Next() = 0;
if MaintenanceLedgerEntry.FindFirst() then
repeat
FAInsertLedgerEntry.CheckMaintReverseEntry(MaintenanceLedgerEntry)
until FALedgerEntry.Next() = 0;
FAInsertLedgerEntry.FinishFAReverseEntry(GLRegister);
if not TempCustLedgerEntry.IsEmpty() then
Error(ReversalMismatchErr, CustLedgerEntry.TableCaption());
if not TempVendorLedgerEntry.IsEmpty() then
Error(ReversalMismatchErr, VendorLedgerEntry.TableCaption());
if not TempEmployeeLedgerEntry.IsEmpty() then
Error(ReversalMismatchErr, EmployeeLedgerEntry.TableCaption());
if not TempBankAccountLedgerEntry.IsEmpty() then
Error(ReversalMismatchErr, BankAccountLedgerEntry.TableCaption());
OnReverseOnBeforeFinishPosting(ReversalEntry, ReversalEntry2, GenJnlPostLine, GLRegister);
GenJnlPostLine.FinishPosting(GenJournalLine);
OnReverseOnAfterFinishPosting(ReversalEntry2, GenJnlPostLine, GLRegister, GLRegister2);
if GLRegister2."No." <> 0 then
if GLRegister2.Find() then begin
GLRegister2.Reversed := true;
GLRegister2.Modify();
end;
DeleteReversalEntries(TransactionKey);
IsHandled := false;
OnReverseOnBeforeUpdateAnalysisView(IsHandled);
if not IsHandled then
UpdateAnalysisView.UpdateAll(0, true);
OnAfterReverse(GLRegister, GLRegister2);
end;
local procedure ReverseGLEntry(var GLEntry2: Record "G/L Entry"; var GenJournalLine: Record "Gen. Journal Line"; var GLRegister: Record "G/L Register"; var TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary; var TempVendorLedgerEntry: Record "Vendor Ledger Entry" temporary; var TempEmployeeLedgerEntry: Record "Employee Ledger Entry" temporary; var TempBankAccountLedgerEntry: Record "Bank Account Ledger Entry" temporary; var NextDtldCustLedgEntryEntryNo: Integer; var NextDtldVendLedgEntryEntryNo: Integer; var NextDtldEmplLedgEntryNo: Integer; FAInsertLedgerEntry: Codeunit "FA Insert Ledger Entry")
var
GLEntry: Record "G/L Entry";
ReversedGLEntry: Record "G/L Entry";
begin
if GLEntry2.Find('+') then
repeat
OnReverseGLEntryOnBeforeLoop(GLEntry2, GenJournalLine, GenJnlPostLine);
if GLEntry2."Reversed by Entry No." <> 0 then
Error(CannotReverseErr);
CheckDimComb(GLEntry2."Entry No.", GLEntry2."Dimension Set ID", Database::"G/L Account", GLEntry2."G/L Account No.", 0, '');
GLEntry := GLEntry2;
if GLEntry2."FA Entry No." <> 0 then
FAInsertLedgerEntry.InsertReverseEntry(
GenJnlPostLine.GetNextEntryNo(), GLEntry2."FA Entry Type", GLEntry2."FA Entry No.", GLEntry."FA Entry No.",
GenJnlPostLine.GetNextTransactionNo());
GLEntry.Amount := -GLEntry2.Amount;
GLEntry."Source Currency Amount" := -GLEntry2."Source Currency Amount";
GLEntry."Source Currency VAT Amount" := -GLEntry2."Source Currency VAT Amount";
GLEntry.Quantity := -GLEntry2.Quantity;
GLEntry."VAT Amount" := -GLEntry2."VAT Amount";
NonDeductibleVAT.Reverse(GLEntry, GLEntry2);
GLEntry."Debit Amount" := -GLEntry2."Debit Amount";
GLEntry."Credit Amount" := -GLEntry2."Credit Amount";
GLEntry."Additional-Currency Amount" := -GLEntry2."Additional-Currency Amount";
GLEntry."Add.-Currency Debit Amount" := -GLEntry2."Add.-Currency Debit Amount";
GLEntry."Add.-Currency Credit Amount" := -GLEntry2."Add.-Currency Credit Amount";
GLEntry."Entry No." := GenJnlPostLine.GetNextEntryNo();
GLEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
GLEntry."G/L Register No." := GLRegister."No.";
GLEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(GLEntry2."User ID"));
GenJournalLine.Correction :=
(GLEntry."Debit Amount" < 0) or (GLEntry."Credit Amount" < 0) or
(GLEntry."Add.-Currency Debit Amount" < 0) or (GLEntry."Add.-Currency Credit Amount" < 0);
GLEntry."Journal Batch Name" := '';
GLEntry."Source Code" := GenJournalLine."Source Code";
SetReversalDescription(GLEntry2, GLEntry.Description);
GLEntry."Reversed Entry No." := GLEntry2."Entry No.";
GLEntry.Reversed := true;
// Reversal of Reversal
if GLEntry2."Reversed Entry No." <> 0 then begin
ReversedGLEntry.Get(GLEntry2."Reversed Entry No.");
ReversedGLEntry."Reversed by Entry No." := 0;
ReversedGLEntry.Reversed := false;
ReversedGLEntry.Modify();
GLEntry2."Reversed Entry No." := GLEntry."Entry No.";
GLEntry."Reversed by Entry No." := GLEntry2."Entry No.";
end;
GLEntry2."Reversed by Entry No." := GLEntry."Entry No.";
GLEntry2.Reversed := true;
GLEntry2.Modify();
OnReverseGLEntryOnBeforeInsertGLEntry(GLEntry, GenJournalLine, GLEntry2, GenJnlPostLine);
GenJnlPostLine.InsertGLEntry(GenJournalLine, GLEntry, false);
OnReverseGLEntryOnAfterInsertGLEntry(GLEntry, GenJournalLine, GLEntry2, GenJnlPostLine);
case true of
TempCustLedgerEntry.Get(GLEntry2."Entry No."):
begin
OnReverseGLEntryOnBeforeTempCustLedgEntryCheckDimComb(GLEntry2, TempCustLedgerEntry);
CheckDimComb(GLEntry2."Entry No.", GLEntry2."Dimension Set ID",
Database::Customer, TempCustLedgerEntry."Customer No.",
Database::"Salesperson/Purchaser", TempCustLedgerEntry."Salesperson Code");
ReverseCustLedgEntry(
TempCustLedgerEntry, GLEntry."Entry No.", GenJournalLine.Correction, GenJournalLine."Source Code",
NextDtldCustLedgEntryEntryNo);
OnReverseGLEntryOnAfterReverseCustLedgEntry(TempCustLedgerEntry, GLEntry, GLEntry2);
TempCustLedgerEntry.Delete();
end;
TempVendorLedgerEntry.Get(GLEntry2."Entry No."):
begin
CheckDimComb(GLEntry2."Entry No.", GLEntry2."Dimension Set ID",
Database::Vendor, TempVendorLedgerEntry."Vendor No.",
Database::"Salesperson/Purchaser", TempVendorLedgerEntry."Purchaser Code");
ReverseVendLedgEntry(
TempVendorLedgerEntry, GLEntry."Entry No.", GenJournalLine.Correction, GenJournalLine."Source Code",
NextDtldVendLedgEntryEntryNo);
OnReverseGLEntryOnAfterReverseVendLedgEntry(TempVendorLedgerEntry, GLEntry, GLEntry2);
TempVendorLedgerEntry.Delete();
end;
TempEmployeeLedgerEntry.Get(GLEntry2."Entry No."):
begin
CheckDimComb(
GLEntry2."Entry No.", GLEntry2."Dimension Set ID", Database::Employee, TempEmployeeLedgerEntry."Employee No.", 0, '');
ReverseEmplLedgEntry(
TempEmployeeLedgerEntry, GLEntry."Entry No.", GenJournalLine.Correction, GenJournalLine."Source Code",
NextDtldEmplLedgEntryNo);
TempEmployeeLedgerEntry.Delete();
end;
TempBankAccountLedgerEntry.Get(GLEntry2."Entry No."):
begin
CheckDimComb(GLEntry2."Entry No.", GLEntry2."Dimension Set ID",
Database::"Bank Account", TempBankAccountLedgerEntry."Bank Account No.", 0, '');
ReverseBankAccLedgEntry(TempBankAccountLedgerEntry, GLEntry."Entry No.", GenJournalLine."Source Code");
TempBankAccountLedgerEntry.Delete();
end;
SpendRequestLinkedToGLEntry(GLEntry2."Entry No."):
ReverseSpendRequest(GLEntry2."Entry No.", GLEntry."Entry No.");
else
OnReverseGLEntryOnCaseElse(GLEntry2, GLEntry, GenJournalLine, GenJnlPostLine, TempBankAccountLedgerEntry);
end;
ReverseVAT(GLEntry, GenJournalLine."Source Code");
OnReverseGLEntryOnAfterReverseVAT(GLEntry2, GLEntry, GenJnlPostLine);
until GLEntry2.Next(-1) = 0;
OnAfterReverseGLEntry(GLEntry);
end;
local procedure ReverseCustLedgEntry(CustLedgerEntry: Record "Cust. Ledger Entry"; NewEntryNo: Integer; Correction: Boolean; SourceCode: Code[10]; var NextDtldCustLedgEntryEntryNo: Integer)
var
NewCustLedgerEntry: Record "Cust. Ledger Entry";
ReversedCustLedgerEntry: Record "Cust. Ledger Entry";
DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry";
NewDetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry";
IsHandled: Boolean;
begin
NewCustLedgerEntry := CustLedgerEntry;
NewCustLedgerEntry."Sales (LCY)" := -NewCustLedgerEntry."Sales (LCY)";
NewCustLedgerEntry."Profit (LCY)" := -NewCustLedgerEntry."Profit (LCY)";
NewCustLedgerEntry."Inv. Discount (LCY)" := -NewCustLedgerEntry."Inv. Discount (LCY)";
NewCustLedgerEntry."Original Pmt. Disc. Possible" := -NewCustLedgerEntry."Original Pmt. Disc. Possible";
NewCustLedgerEntry."Pmt. Disc. Given (LCY)" := -NewCustLedgerEntry."Pmt. Disc. Given (LCY)";
NewCustLedgerEntry.Positive := not NewCustLedgerEntry.Positive;
NewCustLedgerEntry."Adjusted Currency Factor" := NewCustLedgerEntry."Adjusted Currency Factor";
NewCustLedgerEntry."Original Currency Factor" := NewCustLedgerEntry."Original Currency Factor";
NewCustLedgerEntry."Remaining Pmt. Disc. Possible" := -NewCustLedgerEntry."Remaining Pmt. Disc. Possible";
NewCustLedgerEntry."Max. Payment Tolerance" := -NewCustLedgerEntry."Max. Payment Tolerance";
NewCustLedgerEntry."Accepted Payment Tolerance" := -NewCustLedgerEntry."Accepted Payment Tolerance";
NewCustLedgerEntry."Pmt. Tolerance (LCY)" := -NewCustLedgerEntry."Pmt. Tolerance (LCY)";
NewCustLedgerEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewCustLedgerEntry."User ID"));
NewCustLedgerEntry."Entry No." := NewEntryNo;
NewCustLedgerEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewCustLedgerEntry."Journal Batch Name" := '';
NewCustLedgerEntry."Source Code" := SourceCode;
SetReversalDescription(CustLedgerEntry, NewCustLedgerEntry.Description);
NewCustLedgerEntry."Reversed Entry No." := CustLedgerEntry."Entry No.";
NewCustLedgerEntry.Reversed := true;
NewCustLedgerEntry."Applies-to ID" := '';
// Reversal of Reversal
if CustLedgerEntry."Reversed Entry No." <> 0 then begin
ReversedCustLedgerEntry.Get(CustLedgerEntry."Reversed Entry No.");
ReversedCustLedgerEntry."Reversed by Entry No." := 0;
ReversedCustLedgerEntry.Reversed := false;
ReversedCustLedgerEntry.Modify();
CustLedgerEntry."Reversed Entry No." := NewCustLedgerEntry."Entry No.";
NewCustLedgerEntry."Reversed by Entry No." := CustLedgerEntry."Entry No.";
end;
CustLedgerEntry."Applies-to ID" := '';
CustLedgerEntry."Reversed by Entry No." := NewCustLedgerEntry."Entry No.";
CustLedgerEntry.Reversed := true;
OnReverseCustLedgEntryOnBeforeModifyCustLedgerEntry(NewCustLedgerEntry, CustLedgerEntry);
CustLedgerEntry.Modify();
OnReverseCustLedgEntryOnBeforeInsertCustLedgEntry(NewCustLedgerEntry, CustLedgerEntry, GenJnlPostLine);
NewCustLedgerEntry.Insert();
OnReverseCustLedgEntryOnAfterInsertCustLedgEntry(NewCustLedgerEntry, CustLedgerEntry, GenJnlPostLine);
if NextDtldCustLedgEntryEntryNo = 0 then begin
OnReverseCustLedgEntryOnBeforeFindLastDetailedCustLedgEntry(DetailedCustLedgEntry);
DetailedCustLedgEntry.FindLast();
NextDtldCustLedgEntryEntryNo := DetailedCustLedgEntry."Entry No." + 1;
OnReverseCustLedgEntryOnAfterAssignNextDtldCustLedgEntryEntryNo(DetailedCustLedgEntry, NextDtldCustLedgEntryEntryNo);
end;
DetailedCustLedgEntry.SetCurrentKey("Cust. Ledger Entry No.");
DetailedCustLedgEntry.SetRange("Cust. Ledger Entry No.", CustLedgerEntry."Entry No.");
DetailedCustLedgEntry.SetRange(Unapplied, false);
OnReverseCustLedgEntryOnAfterDtldCustLedgEntrySetFilters(DetailedCustLedgEntry, NextDtldCustLedgEntryEntryNo);
DetailedCustLedgEntry.FindSet();
repeat
DetailedCustLedgEntry.TestField("Entry Type", DetailedCustLedgEntry."Entry Type"::"Initial Entry");
NewDetailedCustLedgEntry := DetailedCustLedgEntry;
NewDetailedCustLedgEntry.Amount := -NewDetailedCustLedgEntry.Amount;
NewDetailedCustLedgEntry."Amount (LCY)" := -NewDetailedCustLedgEntry."Amount (LCY)";
NewDetailedCustLedgEntry.UpdateDebitCredit(Correction);
NewDetailedCustLedgEntry."Cust. Ledger Entry No." := NewEntryNo;
NewDetailedCustLedgEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewCustLedgerEntry."User ID"));
NewDetailedCustLedgEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewDetailedCustLedgEntry."Entry No." := NextDtldCustLedgEntryEntryNo;
NextDtldCustLedgEntryEntryNo := NextDtldCustLedgEntryEntryNo + 1;
IsHandled := false;
OnReverseCustLedgEntryOnBeforeInsertDtldCustLedgEntry(NewDetailedCustLedgEntry, DetailedCustLedgEntry, IsHandled, NewCustLedgerEntry);
if not IsHandled then
NewDetailedCustLedgEntry.Insert(true);
OnReverseCustLedgEntryOnAfterInsertDtldCustLedgEntry(NewDetailedCustLedgEntry);
until DetailedCustLedgEntry.Next() = 0;
ApplyCustLedgEntryByReversal(
CustLedgerEntry, NewCustLedgerEntry, NewDetailedCustLedgEntry, NewCustLedgerEntry."Entry No.", NextDtldCustLedgEntryEntryNo);
ApplyCustLedgEntryByReversal(
NewCustLedgerEntry, CustLedgerEntry, DetailedCustLedgEntry, NewCustLedgerEntry."Entry No.", NextDtldCustLedgEntryEntryNo);
end;
local procedure ReverseVendLedgEntry(VendorLedgerEntry: Record "Vendor Ledger Entry"; NewEntryNo: Integer; Correction: Boolean; SourceCode: Code[10]; var NextDtldVendLedgEntryEntryNo: Integer)
var
NewVendorLedgerEntry: Record "Vendor Ledger Entry";
ReversedVendorLedgerEntry: Record "Vendor Ledger Entry";
DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry";
NewDetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry";
IsHandled: Boolean;
begin
NewVendorLedgerEntry := VendorLedgerEntry;
NewVendorLedgerEntry."Purchase (LCY)" := -NewVendorLedgerEntry."Purchase (LCY)";
NewVendorLedgerEntry."Inv. Discount (LCY)" := -NewVendorLedgerEntry."Inv. Discount (LCY)";
NewVendorLedgerEntry."Original Pmt. Disc. Possible" := -NewVendorLedgerEntry."Original Pmt. Disc. Possible";
NewVendorLedgerEntry."Pmt. Disc. Rcd.(LCY)" := -NewVendorLedgerEntry."Pmt. Disc. Rcd.(LCY)";
NewVendorLedgerEntry.Positive := not NewVendorLedgerEntry.Positive;
NewVendorLedgerEntry."Adjusted Currency Factor" := NewVendorLedgerEntry."Adjusted Currency Factor";
NewVendorLedgerEntry."Original Currency Factor" := NewVendorLedgerEntry."Original Currency Factor";
NewVendorLedgerEntry."Remaining Pmt. Disc. Possible" := -NewVendorLedgerEntry."Remaining Pmt. Disc. Possible";
NewVendorLedgerEntry."Max. Payment Tolerance" := -NewVendorLedgerEntry."Max. Payment Tolerance";
NewVendorLedgerEntry."Accepted Payment Tolerance" := -NewVendorLedgerEntry."Accepted Payment Tolerance";
NewVendorLedgerEntry."Pmt. Tolerance (LCY)" := -NewVendorLedgerEntry."Pmt. Tolerance (LCY)";
NewVendorLedgerEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewVendorLedgerEntry."User ID"));
NewVendorLedgerEntry."Entry No." := NewEntryNo;
NewVendorLedgerEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewVendorLedgerEntry."Journal Batch Name" := '';
NewVendorLedgerEntry."Source Code" := SourceCode;
SetReversalDescription(VendorLedgerEntry, NewVendorLedgerEntry.Description);
NewVendorLedgerEntry."Reversed Entry No." := VendorLedgerEntry."Entry No.";
NewVendorLedgerEntry.Reversed := true;
NewVendorLedgerEntry."Applies-to ID" := '';
// Reversal of Reversal
if VendorLedgerEntry."Reversed Entry No." <> 0 then begin
ReversedVendorLedgerEntry.Get(VendorLedgerEntry."Reversed Entry No.");
ReversedVendorLedgerEntry."Reversed by Entry No." := 0;
ReversedVendorLedgerEntry.Reversed := false;
ReversedVendorLedgerEntry.Modify();
VendorLedgerEntry."Reversed Entry No." := NewVendorLedgerEntry."Entry No.";
NewVendorLedgerEntry."Reversed by Entry No." := VendorLedgerEntry."Entry No.";
end;
VendorLedgerEntry."Applies-to ID" := '';
VendorLedgerEntry."Reversed by Entry No." := NewVendorLedgerEntry."Entry No.";
VendorLedgerEntry.Reversed := true;
VendorLedgerEntry.Modify();
OnReverseVendLedgEntryOnBeforeInsertVendLedgEntry(NewVendorLedgerEntry, VendorLedgerEntry, GenJnlPostLine);
NewVendorLedgerEntry.Insert();
OnReverseVendLedgEntryOnAfterInsertVendLedgEntry(NewVendorLedgerEntry);
if NextDtldVendLedgEntryEntryNo = 0 then begin
DetailedVendorLedgEntry.FindLast();
NextDtldVendLedgEntryEntryNo := DetailedVendorLedgEntry."Entry No." + 1;
end;
DetailedVendorLedgEntry.SetCurrentKey("Vendor Ledger Entry No.");
DetailedVendorLedgEntry.SetRange("Vendor Ledger Entry No.", VendorLedgerEntry."Entry No.");
DetailedVendorLedgEntry.SetRange(Unapplied, false);
OnReverseVendLedgEntryOnAfterDtldVendLedgEntrySetFilters(DetailedVendorLedgEntry, NextDtldVendLedgEntryEntryNo);
DetailedVendorLedgEntry.FindSet();
repeat
DetailedVendorLedgEntry.TestField("Entry Type", DetailedVendorLedgEntry."Entry Type"::"Initial Entry");
NewDetailedVendorLedgEntry := DetailedVendorLedgEntry;
NewDetailedVendorLedgEntry.Amount := -NewDetailedVendorLedgEntry.Amount;
NewDetailedVendorLedgEntry."Amount (LCY)" := -NewDetailedVendorLedgEntry."Amount (LCY)";
NewDetailedVendorLedgEntry.UpdateDebitCredit(Correction);
NewDetailedVendorLedgEntry."Vendor Ledger Entry No." := NewEntryNo;
NewDetailedVendorLedgEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewVendorLedgerEntry."User ID"));
NewDetailedVendorLedgEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewDetailedVendorLedgEntry."Entry No." := NextDtldVendLedgEntryEntryNo;
NextDtldVendLedgEntryEntryNo := NextDtldVendLedgEntryEntryNo + 1;
IsHandled := false;
OnReverseVendLedgEntryOnBeforeInsertDtldVendLedgEntry(NewDetailedVendorLedgEntry, DetailedVendorLedgEntry, IsHandled, NewVendorLedgerEntry);
if not IsHandled then
NewDetailedVendorLedgEntry.Insert(true);
OnReverseVendLedgEntryOnAfterInsertDtldVendLedgEntry(NewDetailedVendorLedgEntry, DetailedVendorLedgEntry);
until DetailedVendorLedgEntry.Next() = 0;
ApplyVendLedgEntryByReversal(
VendorLedgerEntry, NewVendorLedgerEntry, NewDetailedVendorLedgEntry, NewVendorLedgerEntry."Entry No.", NextDtldVendLedgEntryEntryNo);
ApplyVendLedgEntryByReversal(
NewVendorLedgerEntry, VendorLedgerEntry, DetailedVendorLedgEntry, NewVendorLedgerEntry."Entry No.", NextDtldVendLedgEntryEntryNo);
end;
local procedure ReverseEmplLedgEntry(EmployeeLedgerEntry: Record "Employee Ledger Entry"; NewEntryNo: Integer; Correction: Boolean; SourceCode: Code[10]; var NextDtldEmplLedgEntryNo: Integer)
var
NewEmployeeLedgerEntry: Record "Employee Ledger Entry";
ReversedEmployeeLedgerEntry: Record "Employee Ledger Entry";
DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry";
NewDetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry";
begin
NewEmployeeLedgerEntry := EmployeeLedgerEntry;
NewEmployeeLedgerEntry.Positive := not NewEmployeeLedgerEntry.Positive;
NewEmployeeLedgerEntry."Adjusted Currency Factor" := NewEmployeeLedgerEntry."Adjusted Currency Factor";
NewEmployeeLedgerEntry."Original Currency Factor" := NewEmployeeLedgerEntry."Original Currency Factor";
NewEmployeeLedgerEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewEmployeeLedgerEntry."User ID"));
NewEmployeeLedgerEntry."Entry No." := NewEntryNo;
NewEmployeeLedgerEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewEmployeeLedgerEntry."Journal Batch Name" := '';
NewEmployeeLedgerEntry."Source Code" := SourceCode;
SetReversalDescription(EmployeeLedgerEntry, NewEmployeeLedgerEntry.Description);
NewEmployeeLedgerEntry."Reversed Entry No." := EmployeeLedgerEntry."Entry No.";
NewEmployeeLedgerEntry.Reversed := true;
NewEmployeeLedgerEntry."Applies-to ID" := '';
// Reversal of Reversal
if EmployeeLedgerEntry."Reversed Entry No." <> 0 then begin
ReversedEmployeeLedgerEntry.Get(EmployeeLedgerEntry."Reversed Entry No.");
ReversedEmployeeLedgerEntry."Reversed by Entry No." := 0;
ReversedEmployeeLedgerEntry.Reversed := false;
ReversedEmployeeLedgerEntry.Modify();
EmployeeLedgerEntry."Reversed Entry No." := NewEmployeeLedgerEntry."Entry No.";
NewEmployeeLedgerEntry."Reversed by Entry No." := EmployeeLedgerEntry."Entry No.";
end;
EmployeeLedgerEntry."Applies-to ID" := '';
EmployeeLedgerEntry."Reversed by Entry No." := NewEmployeeLedgerEntry."Entry No.";
EmployeeLedgerEntry.Reversed := true;
EmployeeLedgerEntry.Modify();
OnReverseEmplLedgEntryOnBeforeInsertEmplLedgEntry(NewEmployeeLedgerEntry, EmployeeLedgerEntry);
NewEmployeeLedgerEntry.Insert();
if NextDtldEmplLedgEntryNo = 0 then begin
DetailedEmployeeLedgerEntry.FindLast();
NextDtldEmplLedgEntryNo := DetailedEmployeeLedgerEntry."Entry No." + 1;
end;
DetailedEmployeeLedgerEntry.SetCurrentKey("Employee Ledger Entry No.");
DetailedEmployeeLedgerEntry.SetRange("Employee Ledger Entry No.", EmployeeLedgerEntry."Entry No.");
DetailedEmployeeLedgerEntry.SetRange(Unapplied, false);
DetailedEmployeeLedgerEntry.FindSet();
repeat
DetailedEmployeeLedgerEntry.TestField("Entry Type", DetailedEmployeeLedgerEntry."Entry Type"::"Initial Entry");
NewDetailedEmployeeLedgerEntry := DetailedEmployeeLedgerEntry;
NewDetailedEmployeeLedgerEntry.Amount := -DetailedEmployeeLedgerEntry.Amount;
NewDetailedEmployeeLedgerEntry."Amount (LCY)" := -DetailedEmployeeLedgerEntry."Amount (LCY)";
NewDetailedEmployeeLedgerEntry.UpdateDebitCredit(Correction);
NewDetailedEmployeeLedgerEntry."Employee Ledger Entry No." := NewEntryNo;
NewDetailedEmployeeLedgerEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewEmployeeLedgerEntry."User ID"));
NewDetailedEmployeeLedgerEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewDetailedEmployeeLedgerEntry."Entry No." := NextDtldEmplLedgEntryNo;
NextDtldEmplLedgEntryNo += 1;
OnReverseEmplLedgEntryOnBeforeInsertDtldEmplLedgEntry(NewDetailedEmployeeLedgerEntry, DetailedEmployeeLedgerEntry);
NewDetailedEmployeeLedgerEntry.Insert(true);
until DetailedEmployeeLedgerEntry.Next() = 0;
ApplyEmplLedgEntryByReversal(
EmployeeLedgerEntry, NewEmployeeLedgerEntry, NewDetailedEmployeeLedgerEntry, NewEmployeeLedgerEntry."Entry No.", NextDtldEmplLedgEntryNo);
ApplyEmplLedgEntryByReversal(
NewEmployeeLedgerEntry, EmployeeLedgerEntry, DetailedEmployeeLedgerEntry, NewEmployeeLedgerEntry."Entry No.", NextDtldEmplLedgEntryNo);
end;
/// <summary>
/// Creates a reversal entry for a bank account ledger entry with opposite amounts and signs.
/// Handles bank account transaction reversal and maintains proper audit trail.
/// </summary>
/// <param name="BankAccountLedgerEntry">Original bank account ledger entry to reverse</param>
/// <param name="NewEntryNo">Entry number for the new reversal entry</param>
/// <param name="SourceCode">Source code to assign to the reversal entry</param>
procedure ReverseBankAccLedgEntry(BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; NewEntryNo: Integer; SourceCode: Code[10])
var
NewBankAccountLedgerEntry: Record "Bank Account Ledger Entry";
ReversedBankAccountLedgerEntry: Record "Bank Account Ledger Entry";
begin
NewBankAccountLedgerEntry := BankAccountLedgerEntry;
NewBankAccountLedgerEntry.Amount := -NewBankAccountLedgerEntry.Amount;
NewBankAccountLedgerEntry."Remaining Amount" := -NewBankAccountLedgerEntry."Remaining Amount";
NewBankAccountLedgerEntry."Amount (LCY)" := -NewBankAccountLedgerEntry."Amount (LCY)";
NewBankAccountLedgerEntry."Debit Amount" := -NewBankAccountLedgerEntry."Debit Amount";
NewBankAccountLedgerEntry."Credit Amount" := -NewBankAccountLedgerEntry."Credit Amount";
NewBankAccountLedgerEntry."Debit Amount (LCY)" := -NewBankAccountLedgerEntry."Debit Amount (LCY)";
NewBankAccountLedgerEntry."Credit Amount (LCY)" := -NewBankAccountLedgerEntry."Credit Amount (LCY)";
NewBankAccountLedgerEntry.Positive := not NewBankAccountLedgerEntry.Positive;
NewBankAccountLedgerEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewBankAccountLedgerEntry."User ID"));
NewBankAccountLedgerEntry."Entry No." := NewEntryNo;
NewBankAccountLedgerEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewBankAccountLedgerEntry."Journal Batch Name" := '';
NewBankAccountLedgerEntry."Source Code" := SourceCode;
SetReversalDescription(BankAccountLedgerEntry, NewBankAccountLedgerEntry.Description);
NewBankAccountLedgerEntry."Reversed Entry No." := BankAccountLedgerEntry."Entry No.";
NewBankAccountLedgerEntry.Reversed := true;
// Reversal of Reversal
if BankAccountLedgerEntry."Reversed Entry No." <> 0 then begin
ReversedBankAccountLedgerEntry.Get(BankAccountLedgerEntry."Reversed Entry No.");
ReversedBankAccountLedgerEntry."Reversed by Entry No." := 0;
ReversedBankAccountLedgerEntry.Reversed := false;
ReversedBankAccountLedgerEntry.Modify();
BankAccountLedgerEntry."Reversed Entry No." := NewBankAccountLedgerEntry."Entry No.";
NewBankAccountLedgerEntry."Reversed by Entry No." := BankAccountLedgerEntry."Entry No.";
end;
BankAccountLedgerEntry."Reversed by Entry No." := NewBankAccountLedgerEntry."Entry No.";
BankAccountLedgerEntry.Reversed := true;
BankAccountLedgerEntry.Modify();
OnReverseBankAccLedgEntryOnBeforeInsert(NewBankAccountLedgerEntry, BankAccountLedgerEntry, GenJnlPostLine);
NewBankAccountLedgerEntry.Insert(true);
end;
/// <summary>
/// Reverses VAT entries associated with a G/L entry by creating offsetting VAT transactions.
/// Handles VAT reversal logic including unrealized VAT and non-deductible VAT amounts.
/// </summary>
/// <param name="GLEntry">G/L entry whose associated VAT entries should be reversed</param>
/// <param name="SourceCode">Source code to assign to the reversal VAT entries</param>
procedure ReverseVAT(GLEntry: Record "G/L Entry"; SourceCode: Code[10])
var
VATEntry: Record "VAT Entry";
NewVATEntry: Record "VAT Entry";
ReversedVATEntry: Record "VAT Entry";
GLEntryVATEntryLink: Record "G/L Entry - VAT Entry Link";
begin
GLEntryVATEntryLink.SetRange("G/L Entry No.", GLEntry."Reversed Entry No.");
if GLEntryVATEntryLink.FindSet() then
repeat
VATEntry.Get(GLEntryVATEntryLink."VAT Entry No.");
if VATEntry."Reversed by Entry No." <> 0 then
Error(CannotReverseErr);
NewVATEntry := VATEntry;
NewVATEntry.Base := -NewVATEntry.Base;
NewVATEntry.Amount := -NewVATEntry.Amount;
NewVATEntry."Source Currency VAT Base" := -NewVATEntry."Source Currency VAT Base";
NewVATEntry."Source Currency VAT Amount" := -NewVATEntry."Source Currency VAT Amount";
NewVATEntry."Unrealized Amount" := -NewVATEntry."Unrealized Amount";
NewVATEntry."Unrealized Base" := -NewVATEntry."Unrealized Base";
NewVATEntry."Remaining Unrealized Amount" := -NewVATEntry."Remaining Unrealized Amount";
NewVATEntry."Remaining Unrealized Base" := -NewVATEntry."Remaining Unrealized Base";
NewVATEntry."Additional-Currency Amount" := -NewVATEntry."Additional-Currency Amount";
NewVATEntry."Additional-Currency Base" := -NewVATEntry."Additional-Currency Base";
NewVATEntry."Add.-Currency Unrealized Amt." := -NewVATEntry."Add.-Currency Unrealized Amt.";
NewVATEntry."Add.-Curr. Rem. Unreal. Amount" := -NewVATEntry."Add.-Curr. Rem. Unreal. Amount";
NewVATEntry."Add.-Curr. Rem. Unreal. Base" := -NewVATEntry."Add.-Curr. Rem. Unreal. Base";
NewVATEntry."VAT Difference" := -NewVATEntry."VAT Difference";
NewVATEntry."Add.-Curr. VAT Difference" := -NewVATEntry."Add.-Curr. VAT Difference";
NonDeductibleVAT.Reverse(NewVATEntry);
NewVATEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewVATEntry."Source Code" := SourceCode;
NewVATEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewVATEntry."User ID"));
NewVATEntry."Entry No." := GenJnlPostLine.GetNextVATEntryNo();
NewVATEntry."Reversed Entry No." := VATEntry."Entry No.";
NewVATEntry.Reversed := true;
// Reversal of Reversal
if VATEntry."Reversed Entry No." <> 0 then begin
ReversedVATEntry.Get(VATEntry."Reversed Entry No.");
ReversedVATEntry."Reversed by Entry No." := 0;
ReversedVATEntry.Reversed := false;
OnReverseVATOnBeforeReversedVATEntryModify(ReversedVATEntry, VATEntry);
ReversedVATEntry.Modify();
VATEntry."Reversed Entry No." := NewVATEntry."Entry No.";
NewVATEntry."Reversed by Entry No." := VATEntry."Entry No.";
end;
VATEntry."Reversed by Entry No." := NewVATEntry."Entry No.";
VATEntry.Reversed := true;
OnReverseVATOnBeforeVATEntryModify(VATEntry);
VATEntry.Modify();
OnReverseVATEntryOnBeforeInsert(NewVATEntry, VATEntry, GenJnlPostLine);
NewVATEntry.Insert();
OnReverseVATEntryOnAfterInsert(NewVATEntry, VATEntry, GenJnlPostLine);
GLEntryVATEntryLink.InsertLink(GLEntry."Entry No.", NewVATEntry."Entry No.");
GenJnlPostLine.IncrNextVATEntryNo();
until GLEntryVATEntryLink.Next() = 0;
end;
local procedure ReverseSpendRequest(OldGLEntryNo: Integer; NewGLEntryNo: Integer)
var
SpendRequestToGLLink: Record "Spend Request To G/L Link";
begin
SpendRequestToGLLink.ReadIsolation(IsolationLevel::UpdLock);
SpendRequestToGLLink.SetRange("G/L Entry No.", OldGLEntryNo);
if not SpendRequestToGLLink.FindFirst() then
exit;
SpendRequestToGLLink."G/L Entry No." := NewGLEntryNo;
SpendRequestToGLLink.Amount := -SpendRequestToGLLink.Amount;
if SpendRequestToGLLink.Insert() then;
end;
local procedure SpendRequestLinkedToGLEntry(GLEntryNo: Integer): Boolean
var
SpendRequestToGLLink: Record "Spend Request To G/L Link";
begin
SpendRequestToGLLink.SetRange("G/L Entry No.", GLEntryNo);
exit(not SpendRequestToGLLink.IsEmpty());
end;
local procedure ApplyCustLedgEntryByReversal(CustLedgerEntry: Record "Cust. Ledger Entry"; CustLedgerEntry2: Record "Cust. Ledger Entry"; DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry"; AppliedEntryNo: Integer; var NextDtldCustLedgEntryEntryNo: Integer)
var
NewDetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeApplyCustLedgEntryByReversal(CustLedgerEntry, CustLedgerEntry2, DetailedCustLedgEntry2, AppliedEntryNo, NextDtldCustLedgEntryEntryNo, GenJnlPostLine, IsHandled);
if not IsHandled then begin
CustLedgerEntry2.CalcFields("Remaining Amount", "Remaining Amt. (LCY)");
CustLedgerEntry."Closed by Entry No." := CustLedgerEntry2."Entry No.";
CustLedgerEntry."Closed at Date" := CustLedgerEntry2."Posting Date";
CustLedgerEntry."Closed by Amount" := -CustLedgerEntry2."Remaining Amount";
CustLedgerEntry."Closed by Amount (LCY)" := -CustLedgerEntry2."Remaining Amt. (LCY)";
CustLedgerEntry."Closed by Currency Code" := CustLedgerEntry2."Currency Code";
CustLedgerEntry."Closed by Currency Amount" := -CustLedgerEntry2."Remaining Amount";
CustLedgerEntry.Open := false;
CustLedgerEntry.Modify();
OnApplyCustLedgEntryByReversalOnAfterCustLedgEntryModify(CustLedgerEntry);
NewDetailedCustLedgEntry := DetailedCustLedgEntry2;
NewDetailedCustLedgEntry."Cust. Ledger Entry No." := CustLedgerEntry."Entry No.";
NewDetailedCustLedgEntry."Entry Type" := NewDetailedCustLedgEntry."Entry Type"::Application;
NewDetailedCustLedgEntry."Applied Cust. Ledger Entry No." := AppliedEntryNo;
NewDetailedCustLedgEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewDetailedCustLedgEntry."User ID"));
NewDetailedCustLedgEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewDetailedCustLedgEntry."Entry No." := NextDtldCustLedgEntryEntryNo;
NextDtldCustLedgEntryEntryNo := NextDtldCustLedgEntryEntryNo + 1;
IsHandled := false;
OnApplyCustLedgEntryByReversalOnBeforeInsertDtldCustLedgEntry(NewDetailedCustLedgEntry, DetailedCustLedgEntry2, IsHandled, GenJnlPostLine, NextDtldCustLedgEntryEntryNo);
if not IsHandled then
NewDetailedCustLedgEntry.Insert(true);
end;
OnApplyCustLedgEntryByReversalOnAfterInsertDtldCustLedgEntry(NewDetailedCustLedgEntry, CustLedgerEntry2);
end;
local procedure ApplyVendLedgEntryByReversal(VendorLedgerEntry: Record "Vendor Ledger Entry"; VendorLedgerEntry2: Record "Vendor Ledger Entry"; DetailedVendorLedgEntry2: Record "Detailed Vendor Ledg. Entry"; AppliedEntryNo: Integer; var NextDtldVendLedgEntryEntryNo: Integer)
var
NewDetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry";
IsHandled: Boolean;
begin
VendorLedgerEntry2.CalcFields("Remaining Amount", "Remaining Amt. (LCY)");
VendorLedgerEntry."Closed by Entry No." := VendorLedgerEntry2."Entry No.";
VendorLedgerEntry."Closed at Date" := VendorLedgerEntry2."Posting Date";
VendorLedgerEntry."Closed by Amount" := -VendorLedgerEntry2."Remaining Amount";
VendorLedgerEntry."Closed by Amount (LCY)" := -VendorLedgerEntry2."Remaining Amt. (LCY)";
VendorLedgerEntry."Closed by Currency Code" := VendorLedgerEntry2."Currency Code";
VendorLedgerEntry."Closed by Currency Amount" := -VendorLedgerEntry2."Remaining Amount";
VendorLedgerEntry.Open := false;
VendorLedgerEntry.Modify();
OnApplyVendLedgEntryByReversalOnAfterVendLedgEntryModify(VendorLedgerEntry);
NewDetailedVendorLedgEntry := DetailedVendorLedgEntry2;
NewDetailedVendorLedgEntry."Vendor Ledger Entry No." := VendorLedgerEntry."Entry No.";
NewDetailedVendorLedgEntry."Entry Type" := NewDetailedVendorLedgEntry."Entry Type"::Application;
NewDetailedVendorLedgEntry."Applied Vend. Ledger Entry No." := AppliedEntryNo;
NewDetailedVendorLedgEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewDetailedVendorLedgEntry."User ID"));
NewDetailedVendorLedgEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewDetailedVendorLedgEntry."Entry No." := NextDtldVendLedgEntryEntryNo;
NextDtldVendLedgEntryEntryNo := NextDtldVendLedgEntryEntryNo + 1;
IsHandled := false;
OnApplyVendLedgEntryByReversalOnBeforeInsertDtldVendLedgEntry(NewDetailedVendorLedgEntry, DetailedVendorLedgEntry2, IsHandled, GenJnlPostLine, NextDtldVendLedgEntryEntryNo);
if not IsHandled then
NewDetailedVendorLedgEntry.Insert(true);
OnApplyVendLedgEntryByReversalOnAfterInsertDtldVendLedgEntry(NewDetailedVendorLedgEntry, VendorLedgerEntry2);
end;
local procedure ApplyEmplLedgEntryByReversal(EmployeeLedgerEntry: Record "Employee Ledger Entry"; EmployeeLedgerEntry2: Record "Employee Ledger Entry"; DetailedEmployeeLedgerEntry2: Record "Detailed Employee Ledger Entry"; AppliedEntryNo: Integer; var NextDtldEmplLedgEntryNo: Integer)
var
NewDetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry";
begin
EmployeeLedgerEntry2.CalcFields("Remaining Amount", "Remaining Amt. (LCY)");
EmployeeLedgerEntry."Closed by Entry No." := EmployeeLedgerEntry2."Entry No.";
EmployeeLedgerEntry."Closed at Date" := EmployeeLedgerEntry2."Posting Date";
EmployeeLedgerEntry."Closed by Amount" := -EmployeeLedgerEntry2."Remaining Amount";
EmployeeLedgerEntry."Closed by Amount (LCY)" := -EmployeeLedgerEntry2."Remaining Amt. (LCY)";
EmployeeLedgerEntry."Closed by Currency Code" := EmployeeLedgerEntry2."Currency Code";
EmployeeLedgerEntry."Closed by Currency Amount" := -EmployeeLedgerEntry2."Remaining Amount";
EmployeeLedgerEntry.Open := false;
EmployeeLedgerEntry.Modify();
NewDetailedEmployeeLedgerEntry := DetailedEmployeeLedgerEntry2;
NewDetailedEmployeeLedgerEntry."Employee Ledger Entry No." := EmployeeLedgerEntry."Entry No.";
NewDetailedEmployeeLedgerEntry."Entry Type" := NewDetailedEmployeeLedgerEntry."Entry Type"::Application;
NewDetailedEmployeeLedgerEntry."Applied Empl. Ledger Entry No." := AppliedEntryNo;
NewDetailedEmployeeLedgerEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewDetailedEmployeeLedgerEntry."User ID"));
NewDetailedEmployeeLedgerEntry."Transaction No." := GenJnlPostLine.GetNextTransactionNo();
NewDetailedEmployeeLedgerEntry."Entry No." := NextDtldEmplLedgEntryNo;
NextDtldEmplLedgEntryNo += 1;
OnApplyEmplLedgEntryByReversalOnBeforeInsertDtldEmplLedgEntry(NewDetailedEmployeeLedgerEntry, DetailedEmployeeLedgerEntry2);
NewDetailedEmployeeLedgerEntry.Insert(true);
end;
/// <summary>
/// Validates dimension combinations for reversal entries to ensure posting compliance.
/// Checks both dimension set validity and dimension value posting restrictions.
/// </summary>
/// <param name="EntryNo">Entry number being validated for error reporting</param>
/// <param name="DimSetID">Dimension set ID to validate</param>
/// <param name="TableID1">Primary table ID for dimension validation</param>
/// <param name="AccNo1">Primary account number for dimension validation</param>
/// <param name="TableID2">Secondary table ID for dimension validation</param>
/// <param name="AccNo2">Secondary account number for dimension validation</param>
procedure CheckDimComb(EntryNo: Integer; DimSetID: Integer; TableID1: Integer; AccNo1: Code[20]; TableID2: Integer; AccNo2: Code[20])
var
DimensionManagement: Codeunit DimensionManagement;
TableID: array[10] of Integer;
AccNo: array[10] of Code[20];
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckDimComb(EntryNo, DimSetID, TableID1, AccNo1, TableID2, AccNo2, IsHandled, DimensionManagement);
if not IsHandled then begin
if not DimensionManagement.CheckDimIDComb(DimSetID) then
Error(DimCombBlockedErr, EntryNo, DimensionManagement.GetDimCombErr());
Clear(TableID);
Clear(AccNo);
TableID[1] := TableID1;
AccNo[1] := AccNo1;
TableID[2] := TableID2;
AccNo[2] := AccNo2;
if not DimensionManagement.CheckDimValuePosting(TableID, AccNo, DimSetID) then
Error(DimensionManagement.GetDimValuePostingErr());
end;
OnAfterCheckDimComb(DimensionManagement);
end;
local procedure CopyCustLedgEntry(var CustLedgerEntry: Record "Cust. Ledger Entry"; var TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary)
begin
if CustLedgerEntry.FindSet() then
repeat
if CustLedgerEntry."Reversed by Entry No." <> 0 then
Error(CannotReverseErr);
TempCustLedgerEntry := CustLedgerEntry;
TempCustLedgerEntry.Insert();
until CustLedgerEntry.Next() = 0;
end;
local procedure CopyVendLedgEntry(var VendorLedgerEntry: Record "Vendor Ledger Entry"; var TempVendorLedgerEntry: Record "Vendor Ledger Entry" temporary)
begin
if VendorLedgerEntry.FindSet() then
repeat
if VendorLedgerEntry."Reversed by Entry No." <> 0 then
Error(CannotReverseErr);
TempVendorLedgerEntry := VendorLedgerEntry;
TempVendorLedgerEntry.Insert();
until VendorLedgerEntry.Next() = 0;
end;
local procedure CopyEmplLedgEntry(var EmployeeLedgerEntry: Record "Employee Ledger Entry"; var TempEmployeeLedgerEntry: Record "Employee Ledger Entry" temporary)
begin
if EmployeeLedgerEntry.FindSet() then
repeat
if EmployeeLedgerEntry."Reversed by Entry No." <> 0 then
Error(CannotReverseErr);
TempEmployeeLedgerEntry := EmployeeLedgerEntry;
TempEmployeeLedgerEntry.Insert();
until EmployeeLedgerEntry.Next() = 0;
end;
local procedure CopyBankAccLedgEntry(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; var TempBankAccountLedgerEntry: Record "Bank Account Ledger Entry" temporary)
begin
if BankAccountLedgerEntry.FindSet() then
repeat
if BankAccountLedgerEntry."Reversed by Entry No." <> 0 then
Error(CannotReverseErr);
TempBankAccountLedgerEntry := BankAccountLedgerEntry;
TempBankAccountLedgerEntry.Insert();
until BankAccountLedgerEntry.Next() = 0;
end;
/// <summary>
/// Sets the description for a reversal entry based on the configured reversal entry description.
/// Retrieves description from corresponding reversal entry record for the source record.
/// </summary>
/// <param name="RecVariant">Source record variant to find matching reversal entry description</param>
/// <param name="Description">Description field to be updated with reversal description</param>
procedure SetReversalDescription(RecVariant: Variant; var Description: Text[100])
var
ReversalEntry: Record "Reversal Entry";
begin
FilterReversalEntry(ReversalEntry, RecVariant);
if ReversalEntry.FindFirst() then
Description := ReversalEntry.Description;
end;
local procedure GetTransactionKey(): Integer
var
ReversalEntry: Record "Reversal Entry";
begin
ReversalEntry.SetCurrentKey("Transaction No.");
ReversalEntry.SetFilter("Transaction No.", '<%1', 0);
if ReversalEntry.FindFirst() then;
exit(ReversalEntry."Transaction No." - 1);
end;
local procedure GetRegisterNoForTransactionReversal(var ReversalEntry: Record "Reversal Entry"): Integer
var
GLRegister: Record "G/L Register";
begin
GLRegister.SetCurrentKey("To Entry No.");
GLRegister.SetRange("To Entry No.", ReversalEntry."Entry No.");
if GLRegister.FindFirst() then;
exit(GLRegister."No.");
end;
local procedure FilterReversalEntry(var ReversalEntry: Record "Reversal Entry"; RecVar: Variant)
var
GLEntry: Record "G/L Entry";
CustLedgerEntry: Record "Cust. Ledger Entry";
VendorLedgerEntry: Record "Vendor Ledger Entry";
EmployeeLedgerEntry: Record "Employee Ledger Entry";
BankAccountLedgerEntry: Record "Bank Account Ledger Entry";
FALedgerEntry: Record "FA Ledger Entry";
MaintenanceLedgerEntry: Record "Maintenance Ledger Entry";
RecRef: RecordRef;
begin
RecRef.GetTable(RecVar);
case RecRef.Number of
Database::"G/L Entry":
begin
ReversalEntry.SetRange("Entry Type", ReversalEntry."Entry Type"::"G/L Account");
GLEntry := RecVar;
ReversalEntry.SetRange("Entry No.", GLEntry."Entry No.");
end;
Database::"Cust. Ledger Entry":
begin
ReversalEntry.SetRange("Entry Type", ReversalEntry."Entry Type"::Customer);
CustLedgerEntry := RecVar;
ReversalEntry.SetRange("Entry No.", CustLedgerEntry."Entry No.");
end;
Database::"Vendor Ledger Entry":
begin
ReversalEntry.SetRange("Entry Type", ReversalEntry."Entry Type"::Vendor);
VendorLedgerEntry := RecVar;
ReversalEntry.SetRange("Entry No.", VendorLedgerEntry."Entry No.");
end;
Database::"Employee Ledger Entry":
begin
ReversalEntry.SetRange("Entry Type", ReversalEntry."Entry Type"::Employee);
EmployeeLedgerEntry := RecVar;
ReversalEntry.SetRange("Entry No.", EmployeeLedgerEntry."Entry No.");
end;
Database::"Bank Account Ledger Entry":
begin
ReversalEntry.SetRange("Entry Type", ReversalEntry."Entry Type"::"Bank Account");
BankAccountLedgerEntry := RecVar;
ReversalEntry.SetRange("Entry No.", BankAccountLedgerEntry."Entry No.");
end;
Database::"FA Ledger Entry":
begin
ReversalEntry.SetRange("Entry Type", ReversalEntry."Entry Type"::"Fixed Asset");
FALedgerEntry := RecVar;
ReversalEntry.SetRange("Entry No.", FALedgerEntry."Entry No.");
end;
Database::"Maintenance Ledger Entry":
begin
ReversalEntry.SetRange("Entry Type", ReversalEntry."Entry Type"::Maintenance);
MaintenanceLedgerEntry := RecVar;
ReversalEntry.SetRange("Entry No.", MaintenanceLedgerEntry."Entry No.");
end;
else
OnAfterFilterReversalEntry(ReversalEntry, RecVar);
end;
end;
local procedure SaveReversalEntries(var TempReversalEntry: Record "Reversal Entry" temporary; TransactionKey: Integer)
var
ReversalEntry: Record "Reversal Entry";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeSaveReversalEntries(IsHandled);
if IsHandled then
exit;
if TempReversalEntry.FindSet() then
repeat
ReversalEntry := TempReversalEntry;
ReversalEntry."Transaction No." := TransactionKey;
ReversalEntry.Insert();
until TempReversalEntry.Next() = 0;
end;
local procedure DeleteReversalEntries(TransactionKey: Integer)
var
ReversalEntry: Record "Reversal Entry";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeDeleteReversalEntries(IsHandled);
if IsHandled then
exit;
ReversalEntry.SetRange("Transaction No.", TransactionKey);
ReversalEntry.DeleteAll();
end;
/// <summary>
/// Integration event raised after setting reversal entry filters to allow additional filter customization.
/// </summary>
/// <param name="ReversalEntry">Reversal entry record with applied filters</param>
/// <param name="RecVar">Source record variant used for filtering</param>
[IntegrationEvent(false, false)]
local procedure OnAfterFilterReversalEntry(var ReversalEntry: Record "Reversal Entry"; RecVar: Variant)
begin
end;
/// <summary>
/// Integration event raised after starting the reversal posting process.
/// </summary>
/// <param name="GenJournalLine">General journal line used for posting</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
/// <param name="GLRegister">G/L register for the reversal</param>
/// <param name="GLRegister2">Original G/L register being reversed</param>
[IntegrationEvent(true, false)]
local procedure OnReverseOnAfterStartPosting(var GenJournalLine: Record "Gen. Journal Line"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var GLRegister: Record "G/L Register"; var GLRegister2: Record "G/L Register")
begin
end;
/// <summary>
/// Integration event raised after completing the entire reversal process.
/// </summary>
/// <param name="GLRegister">G/L register created for the reversal</param>
/// <param name="GLRegister2">Original G/L register that was reversed</param>
[IntegrationEvent(false, false)]
local procedure OnAfterReverse(GLRegister: Record "G/L Register"; var GLRegister2: Record "G/L Register")
begin
end;
/// <summary>
/// Integration event raised after reversing a G/L entry to allow additional processing.
/// </summary>
/// <param name="GLEntry">G/L entry that was reversed</param>
[IntegrationEvent(false, false)]
local procedure OnAfterReverseGLEntry(var GLEntry: Record "G/L Entry")
begin
end;
/// <summary>
/// Integration event raised before starting the reversal process to allow custom validation or preprocessing.
/// </summary>
/// <param name="ReversalEntry">Reversal entries to be processed</param>
/// <param name="ReversalEntry2">Working copy of reversal entries</param>
/// <param name="IsHandled">Set to true to skip standard reversal processing</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeReverse(var ReversalEntry: Record "Reversal Entry"; var ReversalEntry2: Record "Reversal Entry"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before validating dimension combinations to allow custom dimension validation logic.
/// </summary>
/// <param name="EntryNo">Entry number being validated</param>
/// <param name="DimSetID">Dimension set ID to validate</param>
/// <param name="TableID1">Primary table ID for dimension validation</param>
/// <param name="AccNo1">Primary account number for dimension validation</param>
/// <param name="TableID2">Secondary table ID for dimension validation</param>
/// <param name="AccNo2">Secondary account number for dimension validation</param>
/// <param name="IsHandled">Set to true to skip standard dimension validation</param>
/// <param name="DimensionManagement">Dimension management codeunit for validation</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckDimComb(EntryNo: Integer; DimSetID: Integer; TableID1: Integer; AccNo1: Code[20]; TableID2: Integer; AccNo2: Code[20]; var IsHandled: Boolean; var DimensionManagement: Codeunit DimensionManagement)
begin
end;
/// <summary>
/// Integration event raised after inserting a reversed G/L entry.
/// </summary>
/// <param name="GLEntry">New G/L entry created for reversal</param>
/// <param name="GenJnlLine">General journal line used for posting</param>
/// <param name="GLEntry2">Original G/L entry being reversed</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseGLEntryOnAfterInsertGLEntry(var GLEntry: Record "G/L Entry"; GenJnlLine: Record "Gen. Journal Line"; GLEntry2: Record "G/L Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised before inserting a reversed G/L entry to allow modification.
/// </summary>
/// <param name="GLEntry">New G/L entry to be created for reversal</param>
/// <param name="GenJnlLine">General journal line used for posting</param>
/// <param name="GLEntry2">Original G/L entry being reversed</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseGLEntryOnBeforeInsertGLEntry(var GLEntry: Record "G/L Entry"; GenJnlLine: Record "Gen. Journal Line"; GLEntry2: Record "G/L Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised before processing each G/L entry in the reversal loop.
/// </summary>
/// <param name="GLEntry">G/L entry being processed for reversal</param>
/// <param name="GenJournalLine">General journal line used for posting</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseGLEntryOnBeforeLoop(var GLEntry: Record "G/L Entry"; var GenJournalLine: Record "Gen. Journal Line"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised when G/L entry reversal encounters an unhandled ledger entry type.
/// </summary>
/// <param name="GLEntry2">Original G/L entry being processed</param>
/// <param name="GLEntry">New reversal G/L entry</param>
/// <param name="GenJournalLine">General journal line used for posting</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
/// <param name="TempBankAccountLedgerEntry">Temporary bank account ledger entry for processing</param>
[IntegrationEvent(false, false)]
local procedure OnReverseGLEntryOnCaseElse(GLEntry2: Record "G/L Entry"; GLEntry: Record "G/L Entry"; GenJournalLine: Record "Gen. Journal Line"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var TempBankAccountLedgerEntry: Record "Bank Account Ledger Entry" temporary)
begin
end;
/// <summary>
/// Integration event raised after setting filters on detailed customer ledger entries for reversal processing.
/// </summary>
/// <param name="DtldCustLedgEntry">Detailed customer ledger entry with applied filters</param>
/// <param name="NextDtldCustLedgEntryEntryNo">Next entry number for detailed customer ledger entries</param>
[IntegrationEvent(false, false)]
local procedure OnReverseCustLedgEntryOnAfterDtldCustLedgEntrySetFilters(var DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; NextDtldCustLedgEntryEntryNo: Integer)
begin
end;
/// <summary>
/// Integration event raised after inserting a reversed customer ledger entry.
/// </summary>
/// <param name="NewCustLedgerEntry">New customer ledger entry created for reversal</param>
/// <param name="CustLedgerEntry">Original customer ledger entry being reversed</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseCustLedgEntryOnAfterInsertCustLedgEntry(var NewCustLedgerEntry: Record "Cust. Ledger Entry"; CustLedgerEntry: Record "Cust. Ledger Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised before inserting a reversed customer ledger entry to allow modification.
/// </summary>
/// <param name="NewCustLedgerEntry">New customer ledger entry to be created for reversal</param>
/// <param name="CustLedgerEntry">Original customer ledger entry being reversed</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseCustLedgEntryOnBeforeInsertCustLedgEntry(var NewCustLedgerEntry: Record "Cust. Ledger Entry"; CustLedgerEntry: Record "Cust. Ledger Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised before modifying a VAT entry during reversal processing.
/// </summary>
/// <param name="VATEntry">VAT entry being modified for reversal</param>
[IntegrationEvent(false, false)]
local procedure OnReverseVATOnBeforeVATEntryModify(var VATEntry: Record "VAT Entry")
begin
end;
/// <summary>
/// Integration event raised before modifying a reversed VAT entry during reversal of reversal processing.
/// </summary>
/// <param name="ReversedVATEntry">Previously reversed VAT entry being restored</param>
/// <param name="VATEntry">Current VAT entry being processed</param>
[IntegrationEvent(false, false)]
local procedure OnReverseVATOnBeforeReversedVATEntryModify(var ReversedVATEntry: Record "VAT Entry"; var VATEntry: Record "VAT Entry")
begin
end;
/// <summary>
/// Integration event raised after setting filters on detailed vendor ledger entries for reversal processing.
/// </summary>
/// <param name="DtldVendLedgEntry">Detailed vendor ledger entry with applied filters</param>
/// <param name="NextDtldVendLedgEntryEntryNo">Next entry number for detailed vendor ledger entries</param>
[IntegrationEvent(false, false)]
local procedure OnReverseVendLedgEntryOnAfterDtldVendLedgEntrySetFilters(var DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; NextDtldVendLedgEntryEntryNo: Integer)
begin
end;
/// <summary>
/// Integration event raised before inserting a reversed vendor ledger entry to allow modification.
/// </summary>
/// <param name="NewVendLedgEntry">New vendor ledger entry to be created for reversal</param>
/// <param name="VendLedgEntry">Original vendor ledger entry being reversed</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseVendLedgEntryOnBeforeInsertVendLedgEntry(var NewVendLedgEntry: Record "Vendor Ledger Entry"; VendLedgEntry: Record "Vendor Ledger Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised after inserting a reversed vendor ledger entry.
/// </summary>
/// <param name="VendorLedgerEntry">New vendor ledger entry created for reversal</param>
[IntegrationEvent(false, false)]
local procedure OnReverseVendLedgEntryOnAfterInsertVendLedgEntry(var VendorLedgerEntry: Record "Vendor Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before inserting a reversed employee ledger entry to allow modification.
/// </summary>
/// <param name="NewEmployeeLedgerEntry">New employee ledger entry to be created for reversal</param>
/// <param name="EmployeeLedgerEntry">Original employee ledger entry being reversed</param>
[IntegrationEvent(false, false)]
local procedure OnReverseEmplLedgEntryOnBeforeInsertEmplLedgEntry(var NewEmployeeLedgerEntry: Record "Employee Ledger Entry"; EmployeeLedgerEntry: Record "Employee Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before inserting a reversed bank account ledger entry to allow modification.
/// </summary>
/// <param name="NewBankAccLedgEntry">New bank account ledger entry to be created for reversal</param>
/// <param name="BankAccLedgEntry">Original bank account ledger entry being reversed</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseBankAccLedgEntryOnBeforeInsert(var NewBankAccLedgEntry: Record "Bank Account Ledger Entry"; BankAccLedgEntry: Record "Bank Account Ledger Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised before inserting a detailed customer ledger entry during reversal processing.
/// </summary>
/// <param name="NewDtldCustLedgEntry">New detailed customer ledger entry to be inserted</param>
/// <param name="DtldCustLedgEntry">Original detailed customer ledger entry being reversed</param>
/// <param name="IsHandled">Set to true to skip standard insertion processing</param>
/// <param name="NewCustLedgerEntry">New customer ledger entry for the reversal</param>
[IntegrationEvent(false, false)]
local procedure OnReverseCustLedgEntryOnBeforeInsertDtldCustLedgEntry(var NewDtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var IsHandled: Boolean; NewCustLedgerEntry: Record "Cust. Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before inserting a detailed vendor ledger entry during reversal processing.
/// </summary>
/// <param name="NewDtldVendLedgEntry">New detailed vendor ledger entry to be inserted</param>
/// <param name="DtldVendLedgEntry">Original detailed vendor ledger entry being reversed</param>
/// <param name="IsHandled">Set to true to skip standard insertion processing</param>
/// <param name="NewVendorLedgerEntry">New vendor ledger entry for the reversal</param>
[IntegrationEvent(false, false)]
local procedure OnReverseVendLedgEntryOnBeforeInsertDtldVendLedgEntry(var NewDtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; var IsHandled: Boolean; NewVendorLedgerEntry: Record "Vendor Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before inserting a detailed employee ledger entry during reversal processing.
/// </summary>
/// <param name="NewDetailedEmployeeLedgerEntry">New detailed employee ledger entry to be inserted</param>
/// <param name="DetailedEmployeeLedgerEntry">Original detailed employee ledger entry being reversed</param>
[IntegrationEvent(false, false)]
local procedure OnReverseEmplLedgEntryOnBeforeInsertDtldEmplLedgEntry(var NewDetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry"; DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before inserting a reversed VAT entry to allow modification.
/// </summary>
/// <param name="NewVATEntry">New VAT entry to be created for reversal</param>
/// <param name="VATEntry">Original VAT entry being reversed</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseVATEntryOnBeforeInsert(var NewVATEntry: Record "VAT Entry"; VATEntry: Record "VAT Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised before finishing the posting process in reversal to allow final modifications.
/// </summary>
/// <param name="ReversalEntry">Original reversal entry records</param>
/// <param name="ReversalEntry2">Working copy of reversal entries</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
/// <param name="GLRegister">G/L register for the reversal</param>
[IntegrationEvent(false, false)]
local procedure OnReverseOnBeforeFinishPosting(var ReversalEntry: Record "Reversal Entry"; var ReversalEntry2: Record "Reversal Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var GLRegister: Record "G/L Register")
begin
end;
/// <summary>
/// Integration event raised before starting the posting process in reversal to allow preparation.
/// </summary>
/// <param name="GenJournalLine">General journal line to be used for posting</param>
/// <param name="ReversalEntry">Reversal entry records being processed</param>
/// <param name="GLEntry">G/L entry context for posting</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseOnBeforeStartPosting(var GenJournalLine: Record "Gen. Journal Line"; var ReversalEntry: Record "Reversal Entry"; var GLEntry: Record "G/L Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised before reversing G/L entries to allow preprocessing of the reversal operation.
/// </summary>
/// <param name="ReversalEntry2">Working copy of reversal entries</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
/// <param name="GenJournalLine">General journal line for posting</param>
/// <param name="TempRevertTransactionNo">Temporary integer record for transaction numbers</param>
/// <param name="GLEntry2">G/L entry records to be reversed</param>
/// <param name="GLRegister">G/L register for the reversal</param>
[IntegrationEvent(false, false)]
local procedure OnReverseOnBeforeReverseGLEntry(var ReversalEntry2: Record "Reversal Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var GenJournalLine: Record "Gen. Journal Line"; TempRevertTransactionNo: record "Integer"; var GLEntry2: Record "G/L Entry"; GLRegister: Record "G/L Register")
begin
end;
/// <summary>
/// Integration event raised before inserting a detailed customer ledger entry during customer application by reversal.
/// </summary>
/// <param name="NewDtldCustLedgEntry">New detailed customer ledger entry for application</param>
/// <param name="DtldCustLedgEntry">Source detailed customer ledger entry</param>
/// <param name="IsHandled">Set to true to skip standard insertion processing</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
/// <param name="NextDtldCustLedgEntryEntryNo">Next entry number for detailed customer ledger entries</param>
[IntegrationEvent(false, false)]
local procedure OnApplyCustLedgEntryByReversalOnBeforeInsertDtldCustLedgEntry(var NewDtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var IsHandled: Boolean; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var NextDtldCustLedgEntryEntryNo: Integer)
begin
end;
/// <summary>
/// Integration event raised after modifying a customer ledger entry during application by reversal.
/// </summary>
/// <param name="CustLedgerEntry">Customer ledger entry that was modified</param>
[IntegrationEvent(false, false)]
local procedure OnApplyCustLedgEntryByReversalOnAfterCustLedgEntryModify(var CustLedgerEntry: Record "Cust. Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before inserting a detailed vendor ledger entry during vendor application by reversal.
/// </summary>
/// <param name="NewDtldVendLedgEntry">New detailed vendor ledger entry for application</param>
/// <param name="DtldVendLedgEntry">Source detailed vendor ledger entry</param>
/// <param name="IsHandled">Set to true to skip standard insertion processing</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
/// <param name="NextDtldVendLedgEntryEntryNo">Next entry number for detailed vendor ledger entries</param>
[IntegrationEvent(false, false)]
local procedure OnApplyVendLedgEntryByReversalOnBeforeInsertDtldVendLedgEntry(var NewDtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; var IsHandled: Boolean; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var NextDtldVendLedgEntryEntryNo: Integer)
begin
end;
/// <summary>
/// Integration event raised after modifying a vendor ledger entry during application by reversal.
/// </summary>
/// <param name="VendorLedgerEntry">Vendor ledger entry that was modified</param>
[IntegrationEvent(false, false)]
local procedure OnApplyVendLedgEntryByReversalOnAfterVendLedgEntryModify(VendorLedgerEntry: Record "Vendor Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised before inserting a detailed employee ledger entry during employee application by reversal.
/// </summary>
/// <param name="NewDetailedEmployeeLedgerEntry">New detailed employee ledger entry for application</param>
/// <param name="DetailedEmployeeLedgerEntry">Source detailed employee ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnApplyEmplLedgEntryByReversalOnBeforeInsertDtldEmplLedgEntry(var NewDetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry"; DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after finishing the posting process in reversal operation.
/// </summary>
/// <param name="ReversalEntry2">Working copy of reversal entries</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
/// <param name="GLRegister">G/L register created for the reversal</param>
/// <param name="GLRegister2">Original G/L register being reversed</param>
[IntegrationEvent(false, false)]
local procedure OnReverseOnAfterFinishPosting(var ReversalEntry2: Record "Reversal Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var GLRegister: Record "G/L Register"; GLRegister2: Record "G/L Register")
begin
end;
/// <summary>
/// Integration event raised before checking Fixed Asset reversal entries to allow custom validation.
/// </summary>
/// <param name="FALedgerEntry">Fixed Asset ledger entry being validated</param>
/// <param name="FAInsertLedgerEntry">Fixed Asset insertion codeunit</param>
/// <param name="ReversalEntry2">Working copy of reversal entries</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
/// <param name="IsHandled">Set to true to skip standard Fixed Asset reversal validation</param>
[IntegrationEvent(false, false)]
local procedure OnReverseOnBeforeCheckFAReverseEntry(var FALedgerEntry: Record "FA Ledger Entry"; var FAInsertLedgerEntry: Codeunit "FA Insert Ledger Entry"; var ReversalEntry2: Record "Reversal Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised after inserting a detailed vendor ledger entry during reversal processing.
/// </summary>
/// <param name="NewDetailedVendorLedgEntry">New detailed vendor ledger entry that was inserted</param>
/// <param name="DetailedVendorLedgEntry">Original detailed vendor ledger entry</param>
[IntegrationEvent(false, false)]
local procedure OnReverseVendLedgEntryOnAfterInsertDtldVendLedgEntry(var NewDetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry")
begin
end;
/// <summary>
/// Integration event raised before determining transaction key for reversal processing.
/// </summary>
/// <param name="ReversalEntry2">Working copy of reversal entries</param>
/// <param name="TempIntegerAsRevertTransactionNo">Temporary integer record for transaction numbers</param>
[IntegrationEvent(false, false)]
local procedure OnReverseOnBeforeGetTransactionKey(var ReversalEntry2: Record "Reversal Entry"; var TempIntegerAsRevertTransactionNo: Record "Integer" temporary)
begin
end;
/// <summary>
/// Integration event raised after reversing vendor ledger entry in G/L entry processing.
/// </summary>
/// <param name="TempVendorLedgerEntry">Temporary vendor ledger entry that was processed</param>
/// <param name="GLEntry">New G/L entry created for reversal</param>
/// <param name="GLEntry2">Original G/L entry being reversed</param>
[IntegrationEvent(false, false)]
local procedure OnReverseGLEntryOnAfterReverseVendLedgEntry(var TempVendorLedgerEntry: Record "Vendor Ledger Entry" temporary; var GLEntry: Record "G/L Entry"; GLEntry2: Record "G/L Entry")
begin
end;
/// <summary>
/// Integration event raised before updating analysis views to allow custom analysis view handling.
/// </summary>
/// <param name="IsHandled">Set to true to skip standard analysis view update</param>
[IntegrationEvent(false, false)]
local procedure OnReverseOnBeforeUpdateAnalysisView(var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised after reversing VAT entries in G/L entry processing.
/// </summary>
/// <param name="GLEntry2">Original G/L entry being reversed</param>
/// <param name="GLEntry">New G/L entry created for reversal</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseGLEntryOnAfterReverseVAT(GLEntry2: Record "G/L Entry"; GLEntry: Record "G/L Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised after reversing customer ledger entry in G/L entry processing.
/// </summary>
/// <param name="TempCustLedgerEntry">Temporary customer ledger entry that was processed</param>
/// <param name="GLEntry">New G/L entry created for reversal</param>
/// <param name="GLEntry2">Original G/L entry being reversed</param>
[IntegrationEvent(false, false)]
local procedure OnReverseGLEntryOnAfterReverseCustLedgEntry(var TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary; var GLEntry: Record "G/L Entry"; GLEntry2: Record "G/L Entry")
begin
end;
/// <summary>
/// Integration event raised after inserting a detailed customer ledger entry during reversal processing.
/// </summary>
/// <param name="NewDetailedCustLedgEntry">New detailed customer ledger entry that was inserted</param>
[IntegrationEvent(false, false)]
local procedure OnReverseCustLedgEntryOnAfterInsertDtldCustLedgEntry(var NewDetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry")
begin
end;
/// <summary>
/// Integration event raised after inserting a detailed customer ledger entry during customer application by reversal.
/// </summary>
/// <param name="NewDetailedCustLedgEntry">New detailed customer ledger entry that was inserted</param>
/// <param name="CustLedgerEntry2">Customer ledger entry context</param>
[IntegrationEvent(false, false)]
local procedure OnApplyCustLedgEntryByReversalOnAfterInsertDtldCustLedgEntry(var NewDetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; CustLedgerEntry2: Record "Cust. Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after completing dimension combination validation.
/// </summary>
/// <param name="DimensionManagement">Dimension management codeunit used for validation</param>
[IntegrationEvent(false, false)]
local procedure OnAfterCheckDimComb(var DimensionManagement: Codeunit DimensionManagement)
begin
end;
/// <summary>
/// Integration event raised before saving reversal entries to allow custom save processing.
/// </summary>
/// <param name="IsHandled">Set to true to skip standard save processing</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeSaveReversalEntries(var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised before deleting reversal entries to allow custom deletion processing.
/// </summary>
/// <param name="IsHandled">Set to true to skip standard deletion processing</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeDeleteReversalEntries(var IsHandled: Boolean)
begin
end;
/// <summary>
/// Integration event raised after inserting a detailed vendor ledger entry during vendor application by reversal.
/// </summary>
/// <param name="NewDetailedVendorLedgEntry">New detailed vendor ledger entry that was inserted</param>
/// <param name="VendorLedgerEntry2">Vendor ledger entry context</param>
[IntegrationEvent(false, false)]
local procedure OnApplyVendLedgEntryByReversalOnAfterInsertDtldVendLedgEntry(var NewDetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; VendorLedgerEntry2: Record "Vendor Ledger Entry")
begin
end;
/// <summary>
/// Integration event raised after inserting a reversed VAT entry.
/// </summary>
/// <param name="NewVATEntry">New VAT entry that was inserted</param>
/// <param name="VATEntry">Original VAT entry being reversed</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
[IntegrationEvent(false, false)]
local procedure OnReverseVATEntryOnAfterInsert(var NewVATEntry: Record "VAT Entry"; VATEntry: Record "VAT Entry"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line")
begin
end;
/// <summary>
/// Integration event raised before finding the last detailed customer ledger entry to allow custom entry number handling.
/// </summary>
/// <param name="DetailedCustLedgEntry">Detailed customer ledger entry record for finding last entry</param>
[IntegrationEvent(false, false)]
local procedure OnReverseCustLedgEntryOnBeforeFindLastDetailedCustLedgEntry(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry")
begin
end;
/// <summary>
/// Integration event raised after assigning the next detailed customer ledger entry number.
/// </summary>
/// <param name="DetailedCustLedgEntry">Detailed customer ledger entry record context</param>
/// <param name="NextDtldCustLedgEntryEntryNo">Next entry number that was assigned</param>
[IntegrationEvent(false, false)]
local procedure OnReverseCustLedgEntryOnAfterAssignNextDtldCustLedgEntryEntryNo(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var NextDtldCustLedgEntryEntryNo: Integer)
begin
end;
/// <summary>
/// Integration event raised before checking dimension combinations for temporary customer ledger entry.
/// </summary>
/// <param name="GLEntry">G/L entry context for dimension validation</param>
/// <param name="TempCustLedgerEntry">Temporary customer ledger entry being validated</param>
[IntegrationEvent(false, false)]
local procedure OnReverseGLEntryOnBeforeTempCustLedgEntryCheckDimComb(var GLEntry: Record "G/L Entry"; var TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary)
begin
end;
/// <summary>
/// Integration event raised before applying customer ledger entry by reversal to allow custom application logic.
/// </summary>
/// <param name="CustLedgerEntry">Customer ledger entry being applied</param>
/// <param name="CustLedgerEntry2">Customer ledger entry to apply against</param>
/// <param name="DetailedCustLedgEntry2">Detailed customer ledger entry context</param>
/// <param name="AppliedEntryNo">Entry number being applied</param>
/// <param name="NextDtldCustLedgEntryEntryNo">Next detailed entry number</param>
/// <param name="GenJnlPostLine">General journal posting codeunit</param>
/// <param name="IsHandled">Set to true to skip standard application processing</param>
#pragma warning disable AS0077
[IntegrationEvent(false, false)]
local procedure OnBeforeApplyCustLedgEntryByReversal(CustLedgerEntry: Record "Cust. Ledger Entry"; CustLedgerEntry2: Record "Cust. Ledger Entry"; DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry"; AppliedEntryNo: Integer; var NextDtldCustLedgEntryEntryNo: Integer; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var IsHandled: Boolean)
begin
end;
#pragma warning restore AS0077
/// <summary>
/// Integration event raised before modifying a customer ledger entry during reversal processing.
/// </summary>
/// <param name="NewCustLedgerEntry">New customer ledger entry for reversal</param>
/// <param name="CustLedgerEntry">Original customer ledger entry being modified</param>
[IntegrationEvent(false, false)]
local procedure OnReverseCustLedgEntryOnBeforeModifyCustLedgerEntry(NewCustLedgerEntry: Record "Cust. Ledger Entry"; var CustLedgerEntry: Record "Cust. Ledger Entry")
begin
end;
}