Codeunit 17 Gen. Jnl.-Post Reverse
src/Layers/W1/BaseApp/Finance/GeneralLedger/Reversal/GenJnlPostReverse.Codeunit.al1,538 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;}