Codeunit 12 Gen. Jnl.-Post Line

Base Application, Microsoft.Finance.GeneralLedger.Posting

src/Layers/W1/BaseApp/Finance/GeneralLedger/Posting/GenJnlPostLine.Codeunit.al11,164 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.Posting;using Microsoft.Bank.BankAccount;using Microsoft.Bank.Check;using Microsoft.Bank.Ledger;using Microsoft.CostAccounting.Journal;using Microsoft.CostAccounting.Setup;using Microsoft.Finance.Currency;using Microsoft.Finance.Deferral;using Microsoft.Finance.Dimension;using Microsoft.Finance.GeneralLedger.Account;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Ledger;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Finance.ReceivablesPayables;using Microsoft.Finance.SalesTax;using Microsoft.Finance.SpendRequest;using Microsoft.Finance.VAT.Calculation;using Microsoft.Finance.VAT.Ledger;using Microsoft.Finance.VAT.Setup;using Microsoft.FixedAssets.Journal;using Microsoft.FixedAssets.Ledger;using Microsoft.FixedAssets.Maintenance;using Microsoft.FixedAssets.Posting;using Microsoft.Foundation.AuditCodes;using Microsoft.Foundation.Enums;using Microsoft.Foundation.NoSeries;using Microsoft.Foundation.Period;using Microsoft.HumanResources.Employee;using Microsoft.HumanResources.Payables;using Microsoft.Intercompany.Partner;using Microsoft.Projects.Project.Posting;using Microsoft.Purchases.Payables;using Microsoft.Purchases.Setup;using Microsoft.Purchases.Vendor;using Microsoft.Sales.Customer;using Microsoft.Sales.Receivables;using Microsoft.Sales.Reminder;using Microsoft.Sales.Setup;using System.Telemetry;/// <summary>/// Core posting engine for individual general journal lines with comprehensive validation and ledger entry creation./// Handles posting transactions to general ledger, customer/vendor ledgers, VAT entries, and auxiliary registers./// Provides advanced features including currency handling, dimension processing, and deferral management./// </summary>/// <remarks>/// <para>/// <b>Architecture:</b>/// This codeunit serves as the fundamental posting engine for Business Central's general journal system./// It orchestrates the creation of multiple ledger entries from a single journal line, handling complex/// business rules, currency conversions, and cross-module integrations./// </para>/// <para>/// <b>Core Responsibilities:</b>/// </para>/// <list type="bullet">/// <item><description>General ledger entry posting with dimension and currency support</description></item>/// <item><description>Customer and vendor ledger entry creation and application processing</description></item>/// <item><description>VAT calculation and posting including unrealized VAT handling</description></item>/// <item><description>Fixed asset journal integration and depreciation posting</description></item>/// <item><description>Bank account and payment processing</description></item>/// <item><description>Intercompany transaction handling and G/L register maintenance</description></item>/// </list>/// <para>/// <b>Extension Points:</b>/// Supports extensive customization through integration events at key posting stages, enabling/// custom validation, field modifications, and auxiliary posting operations./// </para>/// </remarks>codeunit 12 "Gen. Jnl.-Post Line"{    Permissions = TableData "G/L Account" = r,                  TableData "G/L Entry" = rimd,                  TableData "Cust. Ledger Entry" = rimd,                  tabledata "Customer Posting Group" = R,                  TableData "Vendor Ledger Entry" = rimd,                  tabledata "Vendor Posting Group" = R,                  TableData "G/L Register" = Rimd,                  TableData "G/L Transaction" = Rimd,                  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 "Line Fee Note on Report Hist." = rim,                  TableData "Employee Ledger Entry" = Rimd,                  TableData "Detailed Employee Ledger Entry" = Rimd,                  tabledata "Source Code Setup" = R,                  tabledata "Sales & Receivables Setup" = R,                  tabledata "Purchases & Payables Setup" = R,                  TableData "FA Ledger Entry" = rimd,                  TableData "FA Register" = rimd,                  TableData "Spend Request to G/L Link" = rimd,                  TableData "Maintenance Ledger Entry" = rimd;    TableNo = "Gen. Journal Line";    trigger OnRun()    begin        GetGLSetup();        RunWithCheck(Rec);    end;    var        GLSetup: Record "General Ledger Setup";        GlobalGLEntry: Record "G/L Entry";        GlobalGLTransaction: Record "G/L Transaction";        TempGLEntryBuf: Record "G/L Entry" temporary;        TempGLEntryVAT: Record "G/L Entry" temporary;        TempGLEntryPreview: Record "G/L Entry" temporary;        GLReg: Record "G/L Register";        AddCurrency: Record Currency;        CurrExchRate: Record "Currency Exchange Rate";        VATEntry: Record "VAT Entry";        TaxDetail: Record "Tax Detail";        UnrealizedCustLedgEntry: Record "Cust. Ledger Entry";        UnrealizedVendLedgEntry: Record "Vendor Ledger Entry";        TempGLEntryVATEntryLink: Record "G/L Entry - VAT Entry Link" temporary;        TempVATEntry: Record "VAT Entry" temporary;        TempVendorLedgerEntry: Record "Vendor Ledger Entry" temporary;        TempCustLedgEntry: Record "Cust. Ledger Entry" temporary;        SourceCodeSetup: Record "Source Code Setup";        GenJnlCheckLine: Codeunit "Gen. Jnl.-Check Line";        PaymentToleranceMgt: Codeunit "Payment Tolerance Management";        FAJnlPostLine: Codeunit "FA Jnl.-Post Line";        DeferralUtilities: Codeunit "Deferral Utilities";        NonDeductibleVAT: Codeunit "Non-Deductible VAT";        SequenceNoMgt: Codeunit "Sequence No. Mgt.";        DeferralDocType: Enum "Deferral Document Type";        LastDocType: Enum "Gen. Journal Document Type";        AddCurrencyCode: Code[10];        ApplyingCurrencyCode: Code[10];        JournalsSourceCodesList: List of [Code[10]];        LastDocNo: Code[20];        FiscalYearStartDate: Date;        CurrencyDate: Date;        LastDate: Date;        BalanceCheckAmount: Decimal;        BalanceCheckAmount2: Decimal;        BalanceCheckAddCurrAmount: Decimal;        BalanceCheckAddCurrAmount2: Decimal;        BalanceCheckSrcCurrAmount: Decimal;        BalanceCheckSrcCurrAmount2: Decimal;        CurrentBalance: Decimal;        TotalAddCurrAmount: Decimal;        TotalAmount: Decimal;        UnrealizedRemainingAmountCust: Decimal;        UnrealizedRemainingAmountVend: Decimal;        AmountRoundingPrecision: Decimal;        AddCurrGLEntryVATAmt: Decimal;        CurrencyFactor: Decimal;        FirstEntryNo: Integer;        NextEntryNo: Integer;        NextVATEntryNo: Integer;        NextTaxEntryNo: Integer;        FirstNewVATEntryNo: Integer;        FirstTransactionNo: Integer;        NextTransactionNo: Integer;        NextConnectionNo: Integer;        NextCheckEntryNo: Integer;        InsertedTempGLEntryVAT: Integer;        GLEntryNo: Integer;        UseCurrFactorOnly: Boolean;        NonAddCurrCodeOccured: Boolean;        FADimAlreadyChecked: Boolean;        OverrideDimErr: Boolean;        JobLine: Boolean;        CheckUnrealizedCust: Boolean;        CheckUnrealizedVend: Boolean;        GLSetupRead: Boolean;        PreviewMode: Boolean;        GLEntryInconsistent: Boolean;        MultiplePostingGroups: Boolean;        SourceCodeSetupRead: Boolean;        IsGLRegInserted: Boolean;        IgnoreJournalTemplNameMandatoryCheck: Boolean;        NeedsRoundingErr: Label '%1 needs to be rounded', Comment = '%1 - amount';        PurchaseAlreadyExistsErr: Label 'Purchase %1 %2 already exists for this vendor.', Comment = '%1 = Document Type; %2 = Document No.';        BankPaymentTypeMustNotBeFilledErr: Label 'Bank Payment Type must not be filled if Currency Code is different in Gen. Journal Line and Bank Account.';        DocNoMustBeEnteredErr: Label 'Document No. must be entered when Bank Payment Type is %1.', Comment = '%1 - option value';        CheckAlreadyExistsErr: Label 'Check %1 already exists for this Bank Account.', Comment = '%1 - document no.';        ResidualRoundingErr: Label 'Residual caused by rounding of %1', Comment = '%1 - amount';        DimensionUsedErr: Label 'A dimension used in %1 %2, %3, %4 has caused an error. %5.', Comment = '%1 - table caption, %2 - template name, %3 - batch name, %4 - line no., %5 - error message';        InvalidPostingDateErr: Label '%1 is not within the range of posting dates for deferrals for your company. Check the user setup for the allowed deferrals posting dates.', Comment = '%1=The date passed in for the posting date.';        DescriptionMustNotBeBlankErr: Label 'When %1 is selected for %2, %3 must have a value.', Comment = '%1: Field Omit Default Descr. in Jnl., %2 G/L Account No, %3 Description';        NoDeferralScheduleErr: Label 'You must create a deferral schedule if a deferral template is selected. Line: %1, Deferral Template: %2.', Comment = '%1=The line number of the general ledger transaction, %2=The Deferral Template Code';        ZeroDeferralAmtErr: Label 'Deferral amounts cannot be 0. Line: %1, Deferral Template: %2.', Comment = '%1=The line number of the general ledger transaction, %2=The Deferral Template Code';    /// <summary>    /// Returns the G/L Register that has been created during the posting process.    /// </summary>    /// <param name="NewGLReg">Retun value: G/L Register that has been created during the posting process.</param>    procedure GetGLReg(var NewGLReg: Record "G/L Register")    begin        NewGLReg := GLReg;    end;    /// <summary>    /// Wrapper for the main procedure which checks and posts the journal line.    /// As a result G/L Entries and Register are created along with other related ledger entries.    /// </summary>    /// <param name="GenJnlLine2">Return value: General Journal Line that is being be posted.</param>    /// <returns>No. of the last General Ledger Entry that has been created.</returns>    procedure RunWithCheck(var GenJnlLine2: Record "Gen. Journal Line"): Integer    var        GenJnlLine: Record "Gen. Journal Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRunWithCheck(GenJnlLine, GenJnlLine2, GLEntryNo, IsHandled);        if IsHandled then            exit(GLEntryNo);        if GLReg."No." = 0 then            SequenceNoMgt.ClearSequenceNoCheck();        GenJnlLine.Copy(GenJnlLine2);        Code(GenJnlLine, true);        OnAfterRunWithCheck(GenJnlLine);        GenJnlLine2 := GenJnlLine;        exit(GLEntryNo);    end;    /// <summary>    /// Wrapper for the main procedure posts the journal line without checking it.    /// As a result G/L Entries and Register are created along with other related ledger entries.    /// </summary>    /// <param name="GenJnlLine2">Return value: General Journal Line that is being be posted.</param>    /// <returns>No. of the last General Ledger Entry that has been created.</returns>    procedure RunWithoutCheck(var GenJnlLine2: Record "Gen. Journal Line"): Integer    var        GenJnlLine: Record "Gen. Journal Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRunWithoutCheck(GenJnlLine, GenJnlLine2, GLEntryNo, isHandled);        if IsHandled then            exit(GLEntryNo);        GenJnlLine.Copy(GenJnlLine2);        Code(GenJnlLine, false);        OnAfterRunWithoutCheck(GenJnlLine);        GenJnlLine2 := GenJnlLine;        exit(GLEntryNo);    end;    local procedure "Code"(var GenJnlLine: Record "Gen. Journal Line"; CheckLine: Boolean)    var        xGLEntryNo: Integer;        Balancing: Boolean;        IsTransactionConsistent: Boolean;        IsPosted: Boolean;    begin        IsPosted := false;        OnBeforeCode(GenJnlLine, CheckLine, IsPosted, GLReg, GLEntryNo);        if IsPosted then            exit;        xGLEntryNo := GLEntryNo;        ValidateSequenceNo(GLEntryNo, xGLEntryNo, Database::"G/L Entry");        GetJournalsSourceCode();        if GenJnlLine.EmptyLine() then begin            InitLastDocDate(GenJnlLine);            exit;        end;        if GenJnlLine."VAT Reporting Date" = 0D then begin            GLSetup.Get();            if (GenJnlLine."Document Date" = 0D) and (GLSetup."VAT Reporting Date" = GLSetup."VAT Reporting Date"::"Document Date") then                GenJnlLine."VAT Reporting Date" := GenJnlLine."Posting Date"            else                GenJnlLine."VAT Reporting Date" := GLSetup.GetVATDate(GenJnlLine."Posting Date", GenJnlLine."Document Date");        end;        CheckGenJnlLine(GenJnlLine, CheckLine);        OnCodeOnAfterCheckGenJnlLine(GenJnlLine, CheckLine);        AmountRoundingPrecision := InitAmounts(GenJnlLine);        if GenJnlLine."Bill-to/Pay-to No." = '' then            case true of                GenJnlLine."Account Type" in [GenJnlLine."Account Type"::Customer, GenJnlLine."Account Type"::Vendor]:                    GenJnlLine."Bill-to/Pay-to No." := GenJnlLine."Account No.";                GenJnlLine."Bal. Account Type" in [GenJnlLine."Bal. Account Type"::Customer, GenJnlLine."Bal. Account Type"::Vendor]:                    GenJnlLine."Bill-to/Pay-to No." := GenJnlLine."Bal. Account No.";            end;        if GenJnlLine."Document Date" = 0D then            GenJnlLine."Document Date" := GenJnlLine."Posting Date";        if GenJnlLine."Due Date" = 0D then            GenJnlLine."Due Date" := GenJnlLine."Posting Date";        FindJobLineSign(GenJnlLine);        OnBeforeStartOrContinuePosting(GenJnlLine, LastDocType.AsInteger(), LastDocNo, LastDate, NextEntryNo);        if NextEntryNo = 0 then            StartPosting(GenJnlLine)        else            ContinuePosting(GenJnlLine);        OnCodeOnAfterStartOrContinuePosting(GenJnlLine, LastDocType, LastDocNo, LastDate, NextEntryNo);        if GenJnlLine."Account No." <> '' then begin            if (GenJnlLine."Bal. Account No." <> '') and               (not GenJnlLine."System-Created Entry") and               (GenJnlLine."Account Type" in                [GenJnlLine."Account Type"::Customer,                 GenJnlLine."Account Type"::Vendor,                 GenJnlLine."Account Type"::"Fixed Asset"])            then begin                CODEUNIT.Run(CODEUNIT::"Exchange Acc. G/L Journal Line", GenJnlLine);                OnCodeOnAfterRunExhangeAccGLJournalLine(GenJnlLine, Balancing, NextEntryNo, JobLine);                Balancing := true;            end;            PostGenJnlLine(GenJnlLine, Balancing);        end;        if GenJnlLine."Bal. Account No." <> '' then begin            CODEUNIT.Run(CODEUNIT::"Exchange Acc. G/L Journal Line", GenJnlLine);            OnCodeOnAfterRunExhangeAccGLJournalLine(GenJnlLine, Balancing, NextEntryNo, JobLine);            PostGenJnlLine(GenJnlLine, not Balancing);        end;        CheckPostUnrealizedVAT(GenJnlLine, true);        CreateDeferralScheduleFromGL(GenJnlLine, Balancing);        OnCodeOnBeforeFinishPosting(GenJnlLine, Balancing, FirstEntryNo);        IsTransactionConsistent := FinishPosting(GenJnlLine);        OnAfterGLFinishPosting(            GlobalGLEntry, GenJnlLine, IsTransactionConsistent, FirstTransactionNo, GLReg, TempGLEntryBuf,            NextEntryNo, NextTransactionNo, NextVATEntryNo);        ValidateSequenceNo(GLEntryNo, xGLEntryNo, Database::"G/L Entry");        GLEntryInconsistent := not IsTransactionConsistent;    end;    /// <summary>    /// Specifies if the General Ledger Entries that have been created during the posting process are inconsistent.    /// </summary>    /// <returns>True if the G/L Entry is inconsistent, false otherwise.</returns>    procedure IsGLEntryInconsistent(): Boolean    begin        exit(GLEntryInconsistent);    end;    /// <summary>    /// Shows a list of all inconsistent G/L Entries that has been produced during the posting.    /// </summary>    procedure ShowInconsistentEntries()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeShowInconsistentEntries(TempGLEntryPreview, IsHandled);        if IsHandled then            exit;        Page.Run(Page::"G/L Entries Preview", TempGLEntryPreview);    end;    local procedure CheckGenJnlLine(GenJournalLine: Record "Gen. Journal Line"; CheckLine: Boolean)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckGenJnlLine(GenJournalLine, CheckLine, OverrideDimErr, IsHandled);        if IsHandled then            exit;        if CheckLine then begin            if OverrideDimErr then                GenJnlCheckLine.SetOverDimErr();            if IgnoreJournalTemplNameMandatoryCheck then                GenJnlCheckLine.SetIgnoreJournalTemplNameMandatoryCheck();            OnCheckGenJnlLineOnBeforeRunCheck(GenJournalLine);            GenJnlCheckLine.RunCheck(GenJournalLine);        end;    end;    local procedure PostGenJnlLine(var GenJnlLine: Record "Gen. Journal Line"; Balancing: Boolean)    begin        OnBeforePostGenJnlLine(GenJnlLine, Balancing);        case GenJnlLine."Account Type" of            GenJnlLine."Account Type"::"G/L Account":                PostGLAcc(GenJnlLine, Balancing);            GenJnlLine."Account Type"::Customer:                PostCust(GenJnlLine, Balancing);            GenJnlLine."Account Type"::Vendor:                PostVend(GenJnlLine, Balancing);            GenJnlLine."Account Type"::Employee:                PostEmployee(GenJnlLine);            GenJnlLine."Account Type"::"Bank Account":                PostBankAcc(GenJnlLine, Balancing);            GenJnlLine."Account Type"::"Fixed Asset":                PostFixedAsset(GenJnlLine);            GenJnlLine."Account Type"::"IC Partner":                PostICPartner(GenJnlLine);        end;        OnAfterPostGenJnlLine(GenJnlLine, Balancing);    end;    local procedure InitAmounts(var GenJnlLine: Record "Gen. Journal Line"): Decimal    var        Currency: Record Currency;        VATPostingSetup: Record "VAT Posting Setup";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInitAmounts(GenJnlLine, Currency, IsHandled);        if IsHandled then            exit(Currency."Amount Rounding Precision");        if GenJnlLine."Currency Code" = '' then begin            Currency.InitRoundingPrecision();            GenJnlLine."Amount (LCY)" := GenJnlLine.Amount;            GenJnlLine."VAT Amount (LCY)" := GenJnlLine."VAT Amount";            GenJnlLine."VAT Base Amount (LCY)" := GenJnlLine."VAT Base Amount";        end else begin            Currency.Get(GenJnlLine."Currency Code");            Currency.TestField("Amount Rounding Precision");            if (not GenJnlLine."System-Created Entry") or GenJnlLine."Financial Void" then begin                GenJnlLine."Source Currency Code" := GenJnlLine."Currency Code";                GenJnlLine."Source Currency Amount" := GenJnlLine.Amount;                if GenJnlLine."VAT Calculation Type" = GenJnlLine."VAT Calculation Type"::"Reverse Charge VAT" then begin                    VATPostingSetup.Get(GenJnlLine."VAT Bus. Posting Group", GenJnlLine."VAT Prod. Posting Group");                    GenJnlLine."Source Curr. VAT Base Amount" := GenJnlLine.Amount;                    GenJnlLine."Source Curr. VAT Amount" :=                        Round(                            GenJnlLine.Amount * VATPostingSetup."VAT %" / 100,                            Currency."Amount Rounding Precision", Currency.VATRoundingDirection());                end else begin                    GenJnlLine."Source Curr. VAT Base Amount" := GenJnlLine."VAT Base Amount";                    GenJnlLine."Source Curr. VAT Amount" := GenJnlLine."VAT Amount";                end;            end;        end;        if GenJnlLine."Additional-Currency Posting" = GenJnlLine."Additional-Currency Posting"::None then begin            IsHandled := false;            OnInitAmountsOnAddCurrencyPostingNone(GenJnlLine, IsHandled);            if not IsHandled then begin                if GenJnlLine.Amount <> Round(GenJnlLine.Amount, Currency."Amount Rounding Precision") then                    GenJnlLine.FieldError(                      GenJnlLine.Amount,                      StrSubstNo(NeedsRoundingErr, GenJnlLine.Amount));                if GenJnlLine."Amount (LCY)" <> Round(GenJnlLine."Amount (LCY)") then                    GenJnlLine.FieldError(                      GenJnlLine."Amount (LCY)",                      StrSubstNo(NeedsRoundingErr, GenJnlLine."Amount (LCY)"));            end;        end;        exit(Currency."Amount Rounding Precision");    end;    /// <summary>    /// Assignes information (Document Type, Document No., Posting Date) fron Gen. Journal Line to the global variables.    /// </summary>    /// <param name="GenJnlLine">General Journal Line from which information is taken.</param>    procedure InitLastDocDate(GenJnlLine: Record "Gen. Journal Line")    begin        LastDocType := GenJnlLine."Document Type";        LastDocNo := GenJnlLine."Document No.";        LastDate := GenJnlLine."Posting Date";        OnAfterInitLastDocDate(GenJnlLine);    end;    local procedure InitNextEntryNo()    var        GLEntry: Record "G/L Entry";        LastEntryNo: Integer;        LastTransactionNo: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInitNextEntryNo(GLEntry, NextEntryNo, NextTransactionNo, IsHandled);        if IsHandled then            exit;        GLEntry.LockTable();        GLEntry.GetLastEntry(LastEntryNo, LastTransactionNo);        NextEntryNo := LastEntryNo + 1;        NextTransactionNo := LastTransactionNo + 1;        OnAfterInitNextEntryNo(GLEntry, NextEntryNo, NextTransactionNo);    end;    /// <summary>    /// Initializes the G/L Entry for posting VAT depending on the VAT Posting of the Gen. Journal Line.    /// </summary>    /// <param name="GenJnlLine">Gen. Journal Line that is being posted.</param>    /// <param name="GLEntry">Return value: G/L Entry initialized with information for VAT.</param>    /// <param name="VATPostingSetup">Return value: VAT Posting Setup applicable to Gen. Journal Line that is being posted. Record is retrieved in this procedure and returned.</param>    procedure InitVAT(var GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var VATPostingSetup: Record "VAT Posting Setup")    var        LCYCurrency: Record Currency;        SalesTaxCalculate: Codeunit "Sales Tax Calculate";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInitVAT(GenJnlLine, GLEntry, VATPostingSetup, IsHandled, LCYCurrency, AddCurrencyCode, AddCurrGLEntryVATAmt);        if IsHandled then            exit;        LCYCurrency.InitRoundingPrecision();        if GenJnlLine."Gen. Posting Type" <> GenJnlLine."Gen. Posting Type"::" " then begin            VATPostingSetup.Get(GenJnlLine."VAT Bus. Posting Group", GenJnlLine."VAT Prod. Posting Group");            VATPostingSetup.TestField(Blocked, false);            IsHandled := false;            OnInitVATOnBeforeVATPostingSetupCheck(GenJnlLine, GLEntry, VATPostingSetup, IsHandled);            if not IsHandled then                GenJnlLine.TestField("VAT Calculation Type", VATPostingSetup."VAT Calculation Type");            case GenJnlLine."VAT Posting" of                GenJnlLine."VAT Posting"::"Automatic VAT Entry":                    begin                        GLEntry.CopyPostingGroupsFromGenJnlLine(GenJnlLine);                        case GenJnlLine."VAT Calculation Type" of                            GenJnlLine."VAT Calculation Type"::"Normal VAT":                                begin                                    IsHandled := false;                                    OnInitVATOnVATCalculationTypeNormal(GenJnlLine, IsHandled, GLEntry, VATPostingSetup);                                    if not IsHandled then                                        if GenJnlLine."VAT Difference" <> 0 then begin                                            GLEntry.Amount := GenJnlLine."VAT Base Amount (LCY)";                                            GLEntry."VAT Amount" := GenJnlLine."Amount (LCY)" - GLEntry.Amount;                                            GLEntry."Additional-Currency Amount" := GenJnlLine."Source Curr. VAT Base Amount";                                            if GenJnlLine."Source Currency Code" = AddCurrencyCode then                                                AddCurrGLEntryVATAmt := GenJnlLine."Source Curr. VAT Amount"                                            else                                                AddCurrGLEntryVATAmt := CalcLCYToAddCurr(GLEntry."VAT Amount");                                        end else begin                                            GLEntry."VAT Amount" :=                                              Round(                                                GenJnlLine."Amount (LCY)" * VATPostingSetup."VAT %" / (100 + VATPostingSetup."VAT %"),                                                LCYCurrency."Amount Rounding Precision", LCYCurrency.VATRoundingDirection());                                            OnInitVATOnAfterSetGLEntryVATAmountForNormalVAT(GenJnlLine, GLEntry);                                            GLEntry.Amount := GenJnlLine."Amount (LCY)" - GLEntry."VAT Amount";                                            if GenJnlLine."Source Currency Code" = AddCurrencyCode then                                                AddCurrGLEntryVATAmt :=                                                  Round(                                                    GenJnlLine."Source Currency Amount" * VATPostingSetup."VAT %" / (100 + VATPostingSetup."VAT %"),                                                    AddCurrency."Amount Rounding Precision", AddCurrency.VATRoundingDirection())                                            else                                                AddCurrGLEntryVATAmt := CalcLCYToAddCurr(GLEntry."VAT Amount");                                            GLEntry."Additional-Currency Amount" := GenJnlLine."Source Currency Amount" - AddCurrGLEntryVATAmt;                                        end;                                end;                            GenJnlLine."VAT Calculation Type"::"Reverse Charge VAT":                                case GenJnlLine."Gen. Posting Type" of                                    GenJnlLine."Gen. Posting Type"::Purchase:                                        if GenJnlLine."VAT Difference" <> 0 then begin                                            GLEntry."VAT Amount" := GenJnlLine."VAT Amount (LCY)";                                            if GenJnlLine."Source Currency Code" = AddCurrencyCode then                                                AddCurrGLEntryVATAmt := GenJnlLine."Source Curr. VAT Amount"                                            else                                                AddCurrGLEntryVATAmt := CalcLCYToAddCurr(GLEntry."VAT Amount");                                        end else begin                                            GLEntry."VAT Amount" :=                                              Round(                                                GLEntry.Amount * VATPostingSetup."VAT %" / 100,                                                LCYCurrency."Amount Rounding Precision", LCYCurrency.VATRoundingDirection());                                            if GenJnlLine."Source Currency Code" = AddCurrencyCode then                                                AddCurrGLEntryVATAmt :=                                                  Round(                                                    GLEntry."Additional-Currency Amount" * VATPostingSetup."VAT %" / 100,                                                    AddCurrency."Amount Rounding Precision", AddCurrency.VATRoundingDirection())                                            else                                                AddCurrGLEntryVATAmt := CalcLCYToAddCurr(GLEntry."VAT Amount");                                        end;                                    GenJnlLine."Gen. Posting Type"::Sale:                                        begin                                            GLEntry."VAT Amount" := 0;                                            AddCurrGLEntryVATAmt := 0;                                        end;                                end;                            GenJnlLine."VAT Calculation Type"::"Full VAT":                                begin                                    IsHandled := false;                                    OnInitVATOnBeforeTestFullVATAccount(GenJnlLine, GLEntry, VATPostingSetup, IsHandled);                                    if not IsHandled then                                        case GenJnlLine."Gen. Posting Type" of                                            GenJnlLine."Gen. Posting Type"::Sale:                                                GenJnlLine.TestField("Account No.", VATPostingSetup.GetSalesAccount(false));                                            GenJnlLine."Gen. Posting Type"::Purchase:                                                GenJnlLine.TestField("Account No.", VATPostingSetup.GetPurchAccount(false));                                        end;                                    GLEntry.Amount := 0;                                    GLEntry."Additional-Currency Amount" := 0;                                    GLEntry."Source Currency Amount" := 0;                                    GLEntry."VAT Amount" := GenJnlLine."Amount (LCY)";                                    if GenJnlLine."Source Currency Code" = AddCurrencyCode then                                        AddCurrGLEntryVATAmt := GenJnlLine."Source Currency Amount"                                    else                                        AddCurrGLEntryVATAmt := CalcLCYToAddCurr(GenJnlLine."Amount (LCY)");                                end;                            GenJnlLine."VAT Calculation Type"::"Sales Tax":                                begin                                    if (GenJnlLine."Gen. Posting Type" = GenJnlLine."Gen. Posting Type"::Purchase) and                                       GenJnlLine."Use Tax"                                    then begin                                        GLEntry."VAT Amount" :=                                          Round(                                            SalesTaxCalculate.CalculateTax(                                              GenJnlLine."Tax Area Code", GenJnlLine."Tax Group Code", GenJnlLine."Tax Liable",                                              GenJnlLine."Posting Date", GenJnlLine."Amount (LCY)", GenJnlLine.Quantity, 0));                                        OnAfterSalesTaxCalculateCalculateTax(GenJnlLine, GLEntry, LCYCurrency);                                        GLEntry.Amount := GenJnlLine."Amount (LCY)";                                    end else begin                                        GLEntry.Amount :=                                          Round(                                            SalesTaxCalculate.ReverseCalculateTax(                                              GenJnlLine."Tax Area Code", GenJnlLine."Tax Group Code", GenJnlLine."Tax Liable",                                              GenJnlLine."Posting Date", GenJnlLine."Amount (LCY)", GenJnlLine.Quantity, 0));                                        OnAfterSalesTaxCalculateReverseCalculateTax(GenJnlLine, GLEntry, LCYCurrency);                                        GLEntry."VAT Amount" := GenJnlLine."Amount (LCY)" - GLEntry.Amount;                                    end;                                    GLEntry."Additional-Currency Amount" := GenJnlLine."Source Currency Amount";                                    if GenJnlLine."Source Currency Code" = AddCurrencyCode then                                        AddCurrGLEntryVATAmt := GenJnlLine."Source Curr. VAT Amount"                                    else                                        AddCurrGLEntryVATAmt := CalcLCYToAddCurr(GLEntry."VAT Amount");                                end;                        end;                    end;                GenJnlLine."VAT Posting"::"Manual VAT Entry":                    if GenJnlLine."Gen. Posting Type" <> GenJnlLine."Gen. Posting Type"::Settlement then begin                        GLEntry.CopyPostingGroupsFromGenJnlLine(GenJnlLine);                        GLEntry."VAT Amount" := GenJnlLine."VAT Amount (LCY)";                        if GenJnlLine."Source Currency Code" = AddCurrencyCode then                            AddCurrGLEntryVATAmt := GenJnlLine."Source Curr. VAT Amount"                        else                            AddCurrGLEntryVATAmt := CalcLCYToAddCurr(GenJnlLine."VAT Amount (LCY)");                    end;            end;        end;        if GenJnlLine."System-Created Entry" then            GLEntry."Source Currency VAT Amount" := GenJnlLine."Source Curr. VAT Amount"        else            GLEntry."Source Currency VAT Amount" := CalcAmountSrcCurr(GenJnlLine, GLEntry."VAT Amount");        GLEntry."Additional-Currency Amount" :=                  GLCalcAddCurrency(GLEntry.Amount, GLEntry."Additional-Currency Amount", GLEntry."Additional-Currency Amount", true, GenJnlLine);        NonDeductibleVAT.CopyNonDedVATAmountFromGenJnlLineToGLEntry(GLEntry, GenJnlLine);        OnAfterInitVAT(GenJnlLine, GLEntry, VATPostingSetup, AddCurrGLEntryVATAmt);    end;    /// <summary>    /// Creates and inserts VAT Entries for the Gen. Journal Line that is being posted.    /// If Gen. Journal Line requires Sales Tax, VAT Entries are created and inserted for each Tax Line that is needed.    /// </summary>    /// <param name="GenJnlLine">Gen. Journal Line that is being posted.</param>    /// <param name="GLEntry">G/L Entry for which VAT Entry should be created.</param>    /// <param name="VATPostingSetup">VAT Posting Setup applicable to Gen. Journal Line that is being posted.</param>    procedure PostVAT(GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; VATPostingSetup: Record "VAT Posting Setup")    var        TaxDetail2: Record "Tax Detail";        SalesTaxCalculate: Codeunit "Sales Tax Calculate";        VATAmount: Decimal;        VATAmount2: Decimal;        VATBase: Decimal;        VATBase2: Decimal;        SrcCurrVATAmount: Decimal;        SrcCurrVATBase: Decimal;        SrcCurrSalesTaxBaseAmount: Decimal;        RemSrcCurrVATAmount: Decimal;        SalesTaxBaseAmount: Decimal;        TaxDetailFound: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostVAT(GenJnlLine, GLEntry, VATPostingSetup, IsHandled, AddCurrGLEntryVATAmt, NextConnectionNo, TaxDetail);        if IsHandled then            exit;        case GenJnlLine."VAT Calculation Type" of            GenJnlLine."VAT Calculation Type"::"Normal VAT",            GenJnlLine."VAT Calculation Type"::"Reverse Charge VAT",            GenJnlLine."VAT Calculation Type"::"Full VAT":                begin                    if GenJnlLine."VAT Posting" = GenJnlLine."VAT Posting"::"Automatic VAT Entry" then                        GenJnlLine."VAT Base Amount (LCY)" := GLEntry.Amount;                    if GenJnlLine."Gen. Posting Type" = GenJnlLine."Gen. Posting Type"::Settlement then                        AddCurrGLEntryVATAmt := GenJnlLine."Source Curr. VAT Amount";                    InsertVAT(                      GenJnlLine, VATPostingSetup,                      GLEntry.Amount, GLEntry."VAT Amount", GenJnlLine."VAT Base Amount (LCY)", GenJnlLine."Source Currency Code",                      GLEntry."Additional-Currency Amount", AddCurrGLEntryVATAmt, GenJnlLine."Source Curr. VAT Base Amount");                    NextConnectionNo := NextConnectionNo + 1;                end;            GenJnlLine."VAT Calculation Type"::"Sales Tax":                begin                    case GenJnlLine."VAT Posting" of                        GenJnlLine."VAT Posting"::"Automatic VAT Entry":                            SalesTaxBaseAmount := GLEntry.Amount;                        GenJnlLine."VAT Posting"::"Manual VAT Entry":                            SalesTaxBaseAmount := GenJnlLine."VAT Base Amount (LCY)";                    end;                    if (GenJnlLine."VAT Posting" = GenJnlLine."VAT Posting"::"Manual VAT Entry") and                       (GenJnlLine."Gen. Posting Type" = GenJnlLine."Gen. Posting Type"::Settlement)                    then                        InsertVAT(                          GenJnlLine, VATPostingSetup,                          GLEntry.Amount, GLEntry."VAT Amount", GenJnlLine."VAT Base Amount (LCY)", GenJnlLine."Source Currency Code",                          GenJnlLine."Source Curr. VAT Base Amount", GenJnlLine."Source Curr. VAT Amount", GenJnlLine."Source Curr. VAT Base Amount")                    else begin                        Clear(SalesTaxCalculate);                        SalesTaxCalculate.InitSalesTaxLines(                          GenJnlLine."Tax Area Code", GenJnlLine."Tax Group Code", GenJnlLine."Tax Liable",                          SalesTaxBaseAmount, GenJnlLine.Quantity, GenJnlLine."Posting Date", GLEntry."VAT Amount");                        OnAfterSalesTaxCalculateInitSalesTaxLines(GenJnlLine, GLEntry, SalesTaxBaseAmount);                        SrcCurrVATAmount := 0;                        SrcCurrVATBase := 0;                        SrcCurrSalesTaxBaseAmount := CalcLCYToAddCurr(SalesTaxBaseAmount);                        RemSrcCurrVATAmount := AddCurrGLEntryVATAmt;                        VATAmount2 := 0;                        VATBase2 := 0;                        TaxDetailFound := false;                        while SalesTaxCalculate.GetSalesTaxLine(TaxDetail2, VATAmount, VATBase) do begin                            RemSrcCurrVATAmount := RemSrcCurrVATAmount - SrcCurrVATAmount;                            if TaxDetailFound then                                InsertVAT(                                  GenJnlLine, VATPostingSetup,                                  SalesTaxBaseAmount, VATAmount2, VATBase2, GenJnlLine."Source Currency Code",                                  SrcCurrSalesTaxBaseAmount, SrcCurrVATAmount, SrcCurrVATBase);                            TaxDetailFound := true;                            TaxDetail := TaxDetail2;                            VATAmount2 := VATAmount;                            VATBase2 := VATBase;                            SrcCurrVATAmount := CalcLCYToAddCurr(VATAmount);                            SrcCurrVATBase := CalcLCYToAddCurr(VATBase);                        end;                        if TaxDetailFound then                            InsertVAT(                              GenJnlLine, VATPostingSetup,                              SalesTaxBaseAmount, VATAmount2, VATBase2, GenJnlLine."Source Currency Code",                              SrcCurrSalesTaxBaseAmount, RemSrcCurrVATAmount, SrcCurrVATBase);                        InsertSummarizedVAT(GenJnlLine);                    end;                end;        end;        OnAfterPostVAT(GenJnlLine, GLEntry, VATPostingSetup, TaxDetail, NextConnectionNo, AddCurrGLEntryVATAmt, AddCurrencyCode, UseCurrFactorOnly);    end;    /// <summary>    /// Creates and inserts VAT Entry for the Gen. Journal Line that is being posted.    /// If Calculation Type is Sales Tax, VAT Entries are filled with Tax related information.    /// VAT Posting Parameter is created to be used for the VAT Entry.    /// </summary>    /// <param name="GenJnlLine">Gen. Journal Line that is being posted.</param>    /// <param name="VATPostingSetup">VAT Posting Setup applicable to Gen. Journal Line that is being posted.</param>    /// <param name="GLEntryAmount">Amount that is used for the new VAT Entry Amount if Gen. Posting Type is Settlement.</param>    /// <param name="GLEntryVATAmount">Amount that is used for the new VAT Entry Amount if Gen. Posting Type is not Settlement.</param>    /// <param name="GLEntryBaseAmount">Amount that is used for the new VAT Entry Base.</param>    /// <param name="SrcCurrCode">Currency Code that has been used for the posting transaction (empty if local currency).</param>    /// <param name="SrcCurrGLEntryAmt">Determines new VAT Entry amount after exhange to foreign currency.</param>    /// <param name="SrcCurrGLEntryVATAmt">The VAT Amount to be used for additional currency.</param>    /// <param name="SrcCurrGLEntryBaseAmt">The VAT base to be used for additional currency.</param>    procedure InsertVAT(GenJnlLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; GLEntryAmount: Decimal; GLEntryVATAmount: Decimal; GLEntryBaseAmount: Decimal; SrcCurrCode: Code[10]; SrcCurrGLEntryAmt: Decimal; SrcCurrGLEntryVATAmt: Decimal; SrcCurrGLEntryBaseAmt: Decimal)    var        TaxJurisdiction: Record "Tax Jurisdiction";        VATPostingParameters: Record "VAT Posting Parameters";        VATAmount: Decimal;        VATBase: Decimal;        SrcCurrVATAmount: Decimal;        SrcCurrVATBase: Decimal;        VATDifferenceLCY: Decimal;        SrcCurrVATDifference: Decimal;        NonDedVATDiffACY: Decimal;        UnrealizedVAT: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertVAT(          GenJnlLine, VATEntry, UnrealizedVAT, AddCurrencyCode, VATPostingSetup, GLEntryAmount, GLEntryVATAmount, GLEntryBaseAmount,          SrcCurrCode, SrcCurrGLEntryAmt, SrcCurrGLEntryVATAmt, SrcCurrGLEntryBaseAmt, IsHandled);        if IsHandled then            exit;        VATEntry.Init();        VATEntry.CopyFromGenJnlLine(GenJnlLine);        VATEntry."Entry No." := NextVATEntryNo;        VATEntry."EU Service" := VATPostingSetup."EU Service";        VATEntry."Transaction No." := NextTransactionNo;        VATEntry."Sales Tax Connection No." := NextConnectionNo;        VATEntry.SetVATDateFromGenJnlLine(GenJnlLine);        OnInsertVATOnAfterAssignVATEntryFields(GenJnlLine, VATEntry, CurrExchRate);        if GenJnlLine."VAT Difference" = 0 then            VATDifferenceLCY := 0        else            if GenJnlLine."Currency Code" = '' then                VATDifferenceLCY := GenJnlLine."VAT Difference"            else                VATDifferenceLCY :=                  Round(                    CurrExchRate.ExchangeAmtFCYToLCY(                      GenJnlLine."Posting Date", GenJnlLine."Currency Code", GenJnlLine."VAT Difference",                      CurrExchRate.ExchangeRate(GenJnlLine."Posting Date", GenJnlLine."Currency Code")));        OnInsertVATOnAfterCalcVATDifferenceLCY(GenJnlLine, VATEntry, VATDifferenceLCY, CurrExchRate);        if GenJnlLine."VAT Calculation Type" = GenJnlLine."VAT Calculation Type"::"Sales Tax" then            UpdateVATEntryTaxDetails(GenJnlLine, VATEntry, TaxDetail, TaxJurisdiction);        if AddCurrencyCode <> '' then            if AddCurrencyCode <> SrcCurrCode then begin                SrcCurrGLEntryAmt := ExchangeAmtLCYToFCY2(GLEntryAmount);                SrcCurrGLEntryVATAmt := ExchangeAmtLCYToFCY2(GLEntryVATAmount);                SrcCurrGLEntryBaseAmt := ExchangeAmtLCYToFCY2(GLEntryBaseAmount);                SrcCurrVATDifference := ExchangeAmtLCYToFCY2(VATDifferenceLCY);                NonDedVATDiffACY := ExchangeAmtLCYToFCY2(GenJnlLine."Non-Deductible VAT Diff.");            end else begin                SrcCurrVATDifference := GenJnlLine."VAT Difference";                NonDedVATDiffACY := GenJnlLine."Non-Deductible VAT Diff.";            end;        UnrealizedVAT := SetUnrealizedVAT(GenJnlLine, VATPostingSetup, TaxJurisdiction);        // VAT for VAT entry        if GenJnlLine."Gen. Posting Type" <> GenJnlLine."Gen. Posting Type"::" " then begin            case GenJnlLine."VAT Posting" of                GenJnlLine."VAT Posting"::"Automatic VAT Entry":                    begin                        VATAmount := GLEntryVATAmount;                        VATBase := GLEntryBaseAmount;                        SrcCurrVATAmount := SrcCurrGLEntryVATAmt;                        SrcCurrVATBase := SrcCurrGLEntryBaseAmt;                        NonDeductibleVAT.AdjustVATAmountsFromGenJnlLine(                            VATAmount, VATBase, SrcCurrVATAmount, SrcCurrVATBase, GenJnlLine);                    end;                GenJnlLine."VAT Posting"::"Manual VAT Entry":                    begin                        if GenJnlLine."Gen. Posting Type" = GenJnlLine."Gen. Posting Type"::Settlement then begin                            VATAmount := GLEntryAmount;                            SrcCurrVATAmount := SrcCurrGLEntryVATAmt;                            VATEntry.Closed := true;                        end else begin                            VATAmount := GLEntryVATAmount;                            SrcCurrVATAmount := SrcCurrGLEntryVATAmt;                        end;                        VATBase := GLEntryBaseAmount;                        SrcCurrVATBase := SrcCurrGLEntryBaseAmt;                        if GenJnlLine."Gen. Posting Type" <> GenJnlLine."Gen. Posting Type"::Settlement then                            NonDeductibleVAT.AdjustVATAmountsFromGenJnlLine(                                VATAmount, VATBase, SrcCurrVATAmount, SrcCurrVATBase, GenJnlLine);                    end;            end;            OnInsertVATOnAfterSetVATAmounts(GenJnlLine, VATEntry, GLEntryAmount, GLEntryVATAmount, VATAmount, GLEntryBaseAmount, VATBase, SrcCurrGLEntryAmt, SrcCurrGLEntryVATAmt, SrcCurrVATAmount, SrcCurrGLEntryBaseAmt, SrcCurrVATBase);            if UnrealizedVAT then begin                VATEntry.Amount := 0;                VATEntry.Base := 0;                VATEntry."Unrealized Amount" := VATAmount;                VATEntry."Unrealized Base" := VATBase;                VATEntry."Remaining Unrealized Amount" := VATEntry."Unrealized Amount";                VATEntry."Remaining Unrealized Base" := VATEntry."Unrealized Base";            end else begin                VATEntry.Amount := VATAmount;                VATEntry.Base := VATBase;                VATEntry."Unrealized Amount" := 0;                VATEntry."Unrealized Base" := 0;                VATEntry."Remaining Unrealized Amount" := 0;                VATEntry."Remaining Unrealized Base" := 0;            end;            NonDeductibleVAT.SetNonDedVATInVATEntry(VATEntry, GenJnlLine."Non-Deductible VAT Base LCY", GenJnlLine."Non-Deductible VAT Amount LCY", GenJnlLine."Non-Deductible VAT Base ACY", GenJnlLine."Non-Deductible VAT Amount ACY", GenJnlLine."Non-Deductible VAT Diff.", NonDedVATDiffACY);            if AddCurrencyCode = '' then begin                VATEntry."Additional-Currency Base" := 0;                VATEntry."Additional-Currency Amount" := 0;                VATEntry."Add.-Currency Unrealized Amt." := 0;                VATEntry."Add.-Currency Unrealized Base" := 0;                NonDeductibleVAT.ClearNonDedVATACYInVATEntry(VATEntry);            end else                if UnrealizedVAT then begin                    VATEntry."Additional-Currency Base" := 0;                    VATEntry."Additional-Currency Amount" := 0;                    VATEntry."Add.-Currency Unrealized Base" := SrcCurrVATBase;                    VATEntry."Add.-Currency Unrealized Amt." := SrcCurrVATAmount;                end else begin                    VATEntry."Additional-Currency Base" := SrcCurrVATBase;                    VATEntry."Additional-Currency Amount" := SrcCurrVATAmount;                    VATEntry."Add.-Currency Unrealized Base" := 0;                    VATEntry."Add.-Currency Unrealized Amt." := 0;                end;            VATEntry."Add.-Curr. Rem. Unreal. Amount" := VATEntry."Add.-Currency Unrealized Amt.";            VATEntry."Add.-Curr. Rem. Unreal. Base" := VATEntry."Add.-Currency Unrealized Base";            VATEntry."VAT Difference" := VATDifferenceLCY;            VATEntry."Add.-Curr. VAT Difference" := SrcCurrVATDifference;            if GenJnlLine."System-Created Entry" then                VATEntry."Base Before Pmt. Disc." := GenJnlLine."VAT Base Before Pmt. Disc."            else                VATEntry."Base Before Pmt. Disc." := GLEntryAmount;            VATEntry."G/L Register No." := GLReg."No.";            VATEntry.TestField("G/L Register No.");            OnBeforeInsertVATEntry(VATEntry, GenJnlLine, NextVATEntryNo, TempGLEntryVATEntryLink, TempGLEntryBuf, GLReg);            VATEntry.Insert(true);            TempGLEntryVATEntryLink.InsertLinkSelf(TempGLEntryBuf."Entry No.", VATEntry."Entry No.");            NextVATEntryNo := NextVATEntryNo + 1;            OnAfterInsertVATEntry(GenJnlLine, VATEntry, TempGLEntryBuf."Entry No.", NextVATEntryNo, TempGLEntryVATEntryLink);        end;        // VAT for G/L entry/entries        VATPostingParameters.InsertRecord(            GenJnlLine, VATPostingSetup, GLEntryVATAmount, SrcCurrGLEntryVATAmt, SrcCurrCode, UnrealizedVAT, VATAmount, SrcCurrVATAmount, GenJnlLine."Non-Deductible VAT Amount LCY", GenJnlLine."Non-Deductible VAT Amount ACY");        InsertVATForGLEntry(            GenJnlLine, VATPostingSetup, TaxJurisdiction,            VATPostingParameters);        OnAfterInsertVAT(          GenJnlLine, VATEntry, UnrealizedVAT, AddCurrencyCode, VATPostingSetup, GLEntryAmount, GLEntryVATAmount, GLEntryBaseAmount,          SrcCurrCode, SrcCurrGLEntryAmt, SrcCurrGLEntryVATAmt, SrcCurrGLEntryBaseAmt, AddCurrGLEntryVATAmt,          NextConnectionNo, NextVATEntryNo, NextTransactionNo, TempGLEntryBuf."Entry No.");    end;    local procedure SetUnrealizedVAT(GenJnlLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; TaxJurisdiction: Record "Tax Jurisdiction") UnrealizedVAT: Boolean    begin        UnrealizedVAT :=            (((VATPostingSetup."Unrealized VAT Type" > 0) and            (VATPostingSetup."VAT Calculation Type" in                [VATPostingSetup."VAT Calculation Type"::"Normal VAT",                VATPostingSetup."VAT Calculation Type"::"Reverse Charge VAT",                VATPostingSetup."VAT Calculation Type"::"Full VAT"])) or            ((TaxJurisdiction."Unrealized VAT Type" > 0) and            (VATPostingSetup."VAT Calculation Type" in                [VATPostingSetup."VAT Calculation Type"::"Sales Tax"]))) and            IsNotPayment(GenJnlLine."Document Type");        if GLSetup."Prepayment Unrealized VAT" and not GLSetup."Unrealized VAT" and            (VATPostingSetup."Unrealized VAT Type" > 0)        then            UnrealizedVAT := GenJnlLine.Prepayment;        OnAfterSetUnrealizedVAT(GenJnlLine, VATPostingSetup, UnrealizedVAT);    end;    local procedure InsertVATForGLEntry(var GenJnlLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; TaxJurisdiction: Record "Tax Jurisdiction"; VATPostingParameters: Record "VAT Posting Parameters")    var        GLEntryVATAmountNotEmpty: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertVATForGLEntryFromBuffer(GenJnlLine, VATPostingSetup, VATPostingParameters, IsHandled, VATEntry, TaxJurisdiction, AddCurrencyCode);        if IsHandled then            exit;        GLEntryVATAmountNotEmpty := (VATPostingParameters."Full VAT Amount" <> 0) or (NonDeductibleVAT.GetNonDeductibleVATAmount(GenJnlLine) <> 0);        OnInsertVATOnBeforeVATForGLEntry(GenJnlLine, GLEntryVATAmountNotEmpty);        if GLEntryVATAmountNotEmpty or           ((VATPostingParameters."Full VAT Amount ACY" <> 0) and (VATPostingParameters."Source Currency Code" = AddCurrencyCode))        then            case GenJnlLine."Gen. Posting Type" of                GenJnlLine."Gen. Posting Type"::Purchase:                    case VATPostingSetup."VAT Calculation Type" of                        VATPostingSetup."VAT Calculation Type"::"Normal VAT",                        VATPostingSetup."VAT Calculation Type"::"Full VAT":                            CreateNormalVATGLEntries(GenJnlLine, VATPostingSetup, VATPostingParameters);                        VATPostingSetup."VAT Calculation Type"::"Reverse Charge VAT":                            CreateReverseChargeVATGLEntries(GenJnlLine, VATPostingSetup, VATPostingParameters);                        VATPostingSetup."VAT Calculation Type"::"Sales Tax":                            if GenJnlLine."Use Tax" then begin                                InitGLEntryVAT(GenJnlLine, TaxJurisdiction.GetPurchAccount(VATPostingParameters."Unrealized VAT"), '',                                  VATPostingParameters."Full VAT Amount", VATPostingParameters."Full VAT Amount ACY", true);                                InitGLEntryVAT(GenJnlLine, TaxJurisdiction.GetRevChargeAccount(VATPostingParameters."Unrealized VAT"), '',                                  -VATPostingParameters."Full VAT Amount", -VATPostingParameters."Full VAT Amount ACY", true);                            end else                                InitGLEntryVAT(GenJnlLine, TaxJurisdiction.GetPurchAccount(VATPostingParameters."Unrealized VAT"), '',                                  VATPostingParameters."Full VAT Amount", VATPostingParameters."Full VAT Amount ACY", true);                    end;                GenJnlLine."Gen. Posting Type"::Sale:                    case VATPostingSetup."VAT Calculation Type" of                        VATPostingSetup."VAT Calculation Type"::"Normal VAT",                      VATPostingSetup."VAT Calculation Type"::"Full VAT":                            if GenJnlLine."System-Created Entry" then                                CreateGLEntry(                                      GenJnlLine, VATPostingSetup.GetSalesAccount(VATPostingParameters."Unrealized VAT"),                                      VATPostingParameters."Full VAT Amount", VATPostingParameters."Full VAT Amount ACY", true,                                      GenJnlLine."Source Curr. VAT Amount")                            else                                CreateGLEntry(                                    GenJnlLine, VATPostingSetup.GetSalesAccount(VATPostingParameters."Unrealized VAT"),                                    VATPostingParameters."Full VAT Amount", VATPostingParameters."Full VAT Amount ACY", true,                                    CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Full VAT Amount"));                        VATPostingSetup."VAT Calculation Type"::"Reverse Charge VAT":                            ;                        VATPostingSetup."VAT Calculation Type"::"Sales Tax":                            InitGLEntryVAT(                                GenJnlLine, TaxJurisdiction.GetSalesAccount(VATPostingParameters."Unrealized VAT"), '',                                VATPostingParameters."Full VAT Amount", VATPostingParameters."Full VAT Amount ACY", true);                    end;            end;    end;    local procedure CreateNormalVATGLEntries(GenJnlLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; VATPostingParameters: Record "VAT Posting Parameters")    var        LastNextEntryNo: Integer;    begin        OnBeforeCreateNormalVATGLEntries(GenJnlLine, VATPostingSetup);        if VATPostingParameters."Unrealized VAT" or (VATPostingParameters."Non-Deductible VAT %" <> 100) then            if GenjnlLine."System-Created Entry" then                CreateGLEntry(                    GenJnlLine, VATPostingSetup.GetPurchAccount(VATPostingParameters."Unrealized VAT"),                    VATPostingParameters."Deductible VAT Amount", VATPostingParameters."Deductible VAT Amount ACY", true,                   GenJnlLine."Source Curr. VAT Amount" - CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Non-Deductible VAT Amount"))            else                CreateGLEntry(                    GenJnlLine, VATPostingSetup.GetPurchAccount(VATPostingParameters."Unrealized VAT"),                    VATPostingParameters."Deductible VAT Amount", VATPostingParameters."Deductible VAT Amount ACY", true,                    CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Deductible VAT Amount"));        if VATPostingParameters."Non-Deductible VAT %" <> 0 then            if VATPostingParameters."Non-Ded. Purchase VAT Account" = '' then begin                if GenJnlLine."Account Type" = GenJnlLine."Account Type"::"Fixed Asset" then begin                    LastNextEntryNo := NextEntryNo;                    CreateGLEntry(                        GenJnlLine, GenJnlLine."FA G/L Account No.",                        VATPostingParameters."Non-Deductible VAT Amount", VATPostingParameters."Non-Deductible VAT Amount ACY", true,                        CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Non-Deductible VAT Amount"));                    PostFAJnlLineWithGLEntryBufUpdate(GenJnlLine, VATPostingParameters, LastNextEntryNo);                end else                    CreateGLEntry(                        GenJnlLine, GenJnlLine."Account No.",                        VATPostingParameters."Non-Deductible VAT Amount", VATPostingParameters."Non-Deductible VAT Amount ACY", true,                        CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Non-Deductible VAT Amount"));            end else begin                LastNextEntryNo := NextEntryNo;                CreateGLEntry(                    GenJnlLine, VATPostingParameters."Non-Ded. Purchase VAT Account",                    VATPostingParameters."Non-Deductible VAT Amount", VATPostingParameters."Non-Deductible VAT Amount ACY", true,                    CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Non-Deductible VAT Amount"));                if GenJnlLine."Account Type" = GenJnlLine."Account Type"::"Fixed Asset" then                    PostFAJnlLineWithGLEntryBufUpdate(GenJnlLine, VATPostingParameters, LastNextEntryNo);            end;        OnAfterCreateNormalVATGLEntries(GenJnlLine);    end;    local procedure CreateReverseChargeVATGLEntries(GenJnlLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; VATPostingParameters: Record "VAT Posting Parameters")    var        FullVATAmountSrcCurr: Decimal;        LastNextEntryNo: Integer;    begin        if VATPostingParameters."Unrealized VAT" or not (NonDeductibleVAT.IsNonDeductibleVATEnabled()) then begin            if GenJnlLine."System-Created Entry" and (GenJnlLine."Source Currency Code" <> '') and (GenJnlLine."Source Currency Code" <> GLSetup."LCY Code") then                FullVATAmountSrcCurr := GenJnlLine."Source Curr. VAT Amount"            else                FullVATAmountSrcCurr := CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Full VAT Amount");            OnInsertVATOnBeforeCreateGLEntryForReverseChargeVATToPurchAcc(                GenJnlLine, VATPostingSetup, VATPostingParameters."Unrealized VAT", VATPostingParameters."Full VAT Amount", VATPostingParameters."Full VAT Amount ACY", true);            CreateGLEntry(                GenJnlLine, VATPostingSetup.GetPurchAccount(VATPostingParameters."Unrealized VAT"), VATPostingParameters."Full VAT Amount", VATPostingParameters."Full VAT Amount ACY", true,                FullVATAmountSrcCurr);            OnInsertVATOnBeforeCreateGLEntryForReverseChargeVATToRevChargeAcc(                GenJnlLine, VATPostingSetup, VATPostingParameters."Unrealized VAT", VATPostingParameters."Full VAT Amount", VATPostingParameters."Full VAT Amount ACY", true);            CreateGLEntry(                GenJnlLine, VATPostingSetup.GetRevChargeAccount(VATPostingParameters."Unrealized VAT"), -VATPostingParameters."Full VAT Amount", -VATPostingParameters."Full VAT Amount ACY", true,                -FullVATAmountSrcCurr);            exit;        end;        if VATPostingParameters."Non-Deductible VAT %" <> 100 then begin            CreateGLEntry(                GenJnlLine, VATPostingSetup.GetPurchAccount(VATPostingParameters."Unrealized VAT"), VATPostingParameters."Deductible VAT Amount", VATPostingParameters."Deductible VAT Amount ACY", true,                CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Non-Deductible VAT Amount"));            CreateGLEntry(                GenJnlLine, VATPostingSetup.GetRevChargeAccount(VATPostingParameters."Unrealized VAT"), -VATPostingParameters."Deductible VAT Amount", -VATPostingParameters."Deductible VAT Amount ACY", true,                CalcAmountSrcCurr(GenJnlLine, -VATPostingParameters."Non-Deductible VAT Amount"));        end;        if VATPostingParameters."Non-Deductible VAT %" = 0 then            exit;        if VATPostingParameters."Non-Ded. Purchase VAT Account" = '' then begin            if GenJnlLine."Account Type" = GenJnlLine."Account Type"::"Fixed Asset" then begin                LastNextEntryNo := NextEntryNo;                CreateGLEntry(                    GenJnlLine, GenJnlLine."FA G/L Account No.", VATPostingParameters."Non-Deductible VAT Amount", VATPostingParameters."Non-Deductible VAT Amount ACY", true,                    CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Non-Deductible VAT Amount"));                if GenJnlLine."Account Type" = GenJnlLine."Account Type"::"Fixed Asset" then                    PostFAJnlLineWithGLEntryBufUpdate(GenJnlLine, VATPostingParameters, LastNextEntryNo);                CreateGLEntry(                    GenJnlLine, VATPostingSetup.GetRevChargeAccount(VATPostingParameters."Unrealized VAT"), -VATPostingParameters."Non-Deductible VAT Amount", -VATPostingParameters."Non-Deductible VAT Amount ACY", true,                    CalcAmountSrcCurr(GenJnlLine, -VATPostingParameters."Non-Deductible VAT Amount"));            end else begin                CreateGLEntry(                    GenJnlLine, VATPostingSetup.GetRevChargeAccount(VATPostingParameters."Unrealized VAT"), -VATPostingParameters."Non-Deductible VAT Amount", -VATPostingParameters."Non-Deductible VAT Amount ACY", true,                    CalcAmountSrcCurr(GenJnlLine, -VATPostingParameters."Non-Deductible VAT Amount"));                CreateGLEntry(                    GenJnlLine, GenJnlLine."Account No.", VATPostingParameters."Non-Deductible VAT Amount", VATPostingParameters."Non-Deductible VAT Amount ACY", true,                    CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Non-Deductible VAT Amount"));            end;        end else begin            LastNextEntryNo := NextEntryNo;            CreateGLEntry(                GenJnlLine, VATPostingParameters."Non-Ded. Purchase VAT Account", VATPostingParameters."Non-Deductible VAT Amount", VATPostingParameters."Non-Deductible VAT Amount ACY", true,                CalcAmountSrcCurr(GenJnlLine, VATPostingParameters."Non-Deductible VAT Amount"));            if GenJnlLine."Account Type" = GenJnlLine."Account Type"::"Fixed Asset" then                PostFAJnlLineWithGLEntryBufUpdate(GenJnlLine, VATPostingParameters, LastNextEntryNo);            CreateGLEntry(                GenJnlLine, VATPostingSetup.GetRevChargeAccount(VATPostingParameters."Unrealized VAT"), -VATPostingParameters."Non-Deductible VAT Amount", -VATPostingParameters."Non-Deductible VAT Amount ACY", true,                CalcAmountSrcCurr(GenJnlLine, -VATPostingParameters."Non-Deductible VAT Amount"));        end;    end;    local procedure PostFAJnlLineWithGLEntryBufUpdate(GenJnlLine: Record "Gen. Journal Line"; VATPostingParameters: Record "VAT Posting Parameters"; LastNextEntryNo: Integer)    var        TempFAGLPostingBuffer: Record "FA G/L Posting Buffer" temporary;        GLBalanceAmount: Decimal;        IsLastDepreciationEntry: Boolean;    begin        if not NonDeductibleVAT.UseNonDeductibleVATAmountForFixedAssetCost() then            exit;        GenJnlLine."Non-Ded. VAT FA Cost" := true;        FAJnlPostLine.GenJnlPostLine(GenJnlLine, VATPostingParameters."Non-Deductible VAT Amount", 0, NextTransactionNo, LastNextEntryNo, GLReg."No.");        GenJnlLine."Non-Ded. VAT FA Cost" := false;        if FAJnlPostLine.FindFirstGLAcc(TempFAGLPostingBuffer) then            repeat                PostFAGLPostingBuffer(GenJnlLine, TempFAGLPostingBuffer, GLBalanceAmount, IsLastDepreciationEntry);            until FAJnlPostLine.GetNextGLAcc(TempFAGLPostingBuffer) = 0;    end;    /// <summary>    /// Creates G/L Entries for VAT. If summarization is needed, before creating new entry existing ones in TempGLEntryVAT.    /// buffer are checked. If entry in the buffer for the same G/L Account and Bal. Account already exists, just the amount is increased.    /// </summary>    /// <param name="SummarizeGLEntries">Flag if entries should be summarized.</param>    /// <param name="GLEntry">G/L Entry for which VAT G/L Entry should be created or adjusted.</param>    procedure SummarizeVAT(SummarizeGLEntries: Boolean; GLEntry: Record "G/L Entry")    var        InsertedTempVAT: Boolean;    begin        InsertedTempVAT := false;        if SummarizeGLEntries then            if TempGLEntryVAT.FindSet() then                repeat                    if (TempGLEntryVAT."G/L Account No." = GLEntry."G/L Account No.") and                       (TempGLEntryVAT."Bal. Account No." = GLEntry."Bal. Account No.")                    then begin                        TempGLEntryVAT.Amount := TempGLEntryVAT.Amount + GLEntry.Amount;                        TempGLEntryVAT."Additional-Currency Amount" :=                          TempGLEntryVAT."Additional-Currency Amount" + GLEntry."Additional-Currency Amount";                        TempGLEntryVAT.Modify();                        InsertedTempVAT := true;                    end;                until (TempGLEntryVAT.Next() = 0) or InsertedTempVAT;        if not InsertedTempVAT or not SummarizeGLEntries then begin            TempGLEntryVAT := GLEntry;            TempGLEntryVAT."Entry No." :=              TempGLEntryVAT."Entry No." + InsertedTempGLEntryVAT;            TempGLEntryVAT.Insert();            InsertedTempGLEntryVAT := InsertedTempGLEntryVAT + 1;        end;    end;    /// <summary>    /// Inserts summarized VAT G/L Entries for the Gen. Journal Line that is being posted.    /// Summarized entries are taken from TempGLEntryVAT buffer.    /// </summary>    /// <remarks>    /// Global G/L Entry buffer for VAT is cleared at the end of procedure.    /// </remarks>    /// <param name="GenJnlLine">Gen. Journal Line that is being posted.</param>    procedure InsertSummarizedVAT(GenJnlLine: Record "Gen. Journal Line")    begin        if TempGLEntryVAT.FindSet() then begin            repeat                InsertGLEntry(GenJnlLine, TempGLEntryVAT, true);                OnInsertSummarizedVATOnAfterInsertGLEntry(GenJnlLine, TempGLEntryVAT, NextEntryNo);            until TempGLEntryVAT.Next() = 0;            TempGLEntryVAT.DeleteAll();            InsertedTempGLEntryVAT := 0;        end;        NextConnectionNo := NextConnectionNo + 1;    end;    local procedure CheckDescriptionForGL(GLAccount: Record "G/L Account"; Description: Text[100])    var        GLEntry: Record "G/L Entry";    begin        if GLAccount."Omit Default Descr. in Jnl." then            if DelChr(Description, '=', ' ') = '' then                Error(                    DescriptionMustNotBeBlankErr,                    GLAccount.FieldCaption("Omit Default Descr. in Jnl."),                    GLAccount."No.",                    GLEntry.FieldCaption(Description));    end;    local procedure PostGLAcc(GenJnlLine: Record "Gen. Journal Line"; Balancing: Boolean)    var        GLAcc: Record "G/L Account";        GLEntry: Record "G/L Entry";        VATPostingSetup: Record "VAT Posting Setup";        TaxAmount: Decimal;        TaxAmountLCY: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostGLAcc(GenJnlLine, GLEntry, GLEntryNo, IsHandled, TempGLEntryBuf);        if not IsHandled then begin            GLAcc.Get(GenJnlLine."Account No.");            OnBeforeInitGLEntryForGLAcc(GenJnlLine, GLAcc, GLEntry, TaxAmount, TaxAmountLCY, IsHandled);            if not IsHandled then                InitGLEntry(                    GenJnlLine, GLEntry, GenJnlLine."Account No.", GenJnlLine."Amount (LCY)",                    GenJnlLine."Source Currency Amount", true, GenJnlLine."System-Created Entry",                    CalcSourceCurrVATBaseAmount(GenJnlLine));            IsHandled := false;            OnPostGLAccOnAfterInitGLEntry(GenJnlLine, GLEntry);            CheckGLAccDirectPosting(GenJnlLine, GLAcc);            CheckDescriptionForGL(GLAcc, GenJnlLine.Description);            GLEntry."Gen. Posting Type" := GenJnlLine."Gen. Posting Type";            GLEntry."Bal. Account Type" := GenJnlLine."Bal. Account Type";            GLEntry."Bal. Account No." := GenJnlLine."Bal. Account No.";            GLEntry."No. Series" := GenJnlLine."Posting No. Series";            GLEntry."Journal Templ. Name" := GenJnlLine."Journal Template Name";            if GenJnlLine."Additional-Currency Posting" =               GenJnlLine."Additional-Currency Posting"::"Additional-Currency Amount Only"            then begin                GLEntry."Additional-Currency Amount" := GenJnlLine.Amount;                GLEntry.Amount := 0;            end;            // Store Entry No. to global variable for return:            GLEntryNo := GLEntry."Entry No.";            InitVAT(GenJnlLine, GLEntry, VATPostingSetup);            IsHandled := false;            OnPostGLAccOnBeforeInsertGLEntry(GenJnlLine, GLEntry, IsHandled, Balancing);            if not IsHandled then                if not ((GenJnlLine."Deferral Code" <> '') and (GenJnlLine.Amount = 0)) then                    InsertGLEntry(GenJnlLine, GLEntry, true);            IsHandled := false;            OnPostGLAccOnBeforePostJob(GenJnlLine, GLEntry, IsHandled, Balancing);            if not IsHandled then                PostJob(GenJnlLine, GLEntry);            PostVAT(GenJnlLine, GLEntry, VATPostingSetup);            OnPostGLAccOnBeforeDeferralPosting(GenJnlLine, TaxAmount, TaxAmountLCY);            DeferralPosting(GenJnlLine."Deferral Code", GenJnlLine."Source Code", GenJnlLine."Account No.", GenJnlLine, Balancing);        end;        OnMoveGenJournalLine(GenJnlLine, GLEntry.RecordId);        OnAfterPostGLAcc(GenJnlLine, TempGLEntryBuf, NextEntryNo, NextTransactionNo, Balancing, GLEntry, VATPostingSetup, TempGLEntryVATEntryLink);    end;    local procedure PostCust(var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean)    var        LineFeeNoteOnReportHist: Record "Line Fee Note on Report Hist.";        Cust: Record Customer;        CustPostingGr: Record "Customer Posting Group";        CustLedgEntry: Record "Cust. Ledger Entry";        CVLedgEntryBuf: Record "CV Ledger Entry Buffer";        TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary;        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        SalesSetup: Record "Sales & Receivables Setup";        ReceivablesAccount: Code[20];        DtldLedgEntryInserted: Boolean;        ShouldCheckDocNo: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostCust(GenJournalLine, Balancing, IsHandled);        if not IsHandled then begin            SalesSetup.Get();            Cust.Get(GenJournalLine."Account No.");            Cust.CheckBlockedCustOnJnls(Cust, GenJournalLine, true);            Cust.TestField("Customer Posting Group");            if GenJournalLine."Posting Group" = '' then                GenJournalLine."Posting Group" := Cust."Customer Posting Group"            else                if GenJournalLine."Posting Group" <> Cust."Customer Posting Group" then                    Cust.CheckAllowMultiplePostingGroups();            OnPostCustOnBeforeGetCustomerPostingGroup(GenJournalLine);            GetCustomerPostingGroup(GenJournalLine, CustPostingGr);            ReceivablesAccount := GetCustomerReceivablesAccount(GenJournalLine, CustPostingGr);            OnPostCustOnAfterAssignReceivablesAccount(GenJournalLine, CustPostingGr, ReceivablesAccount);            DtldCustLedgEntry.LockTable();            CustLedgEntry.LockTable();            OnPostCustOnBeforeInitCustLedgEntry(GenJournalLine, CustLedgEntry, CVLedgEntryBuf, TempDtldCVLedgEntryBuf, CustPostingGr);            InitCustLedgEntry(GenJournalLine, CustLedgEntry);            OnPostCustOnAfterInitCustLedgEntry(GenJournalLine, CustLedgEntry, Cust, CustPostingGr);            if not Cust."Block Payment Tolerance" then                CalcPmtTolerancePossible(                    GenJournalLine, CustLedgEntry."Pmt. Discount Date", CustLedgEntry."Pmt. Disc. Tolerance Date",                    CustLedgEntry."Max. Payment Tolerance");            TempDtldCVLedgEntryBuf.DeleteAll();            TempDtldCVLedgEntryBuf.Init();            OnPostCustOnBeforeTempDtldCVLedgEntryBufCopyFromGenJnlLine(GenJournalLine, CustLedgEntry, Cust, GLReg, CVLedgEntryBuf);            TempDtldCVLedgEntryBuf.CopyFromGenJnlLine(GenJournalLine);            OnPostCustOnAfterTempDtldCVLedgEntryBufCopyFromGenJnlLine(GenJournalLine, TempDtldCVLedgEntryBuf);            TempDtldCVLedgEntryBuf."CV Ledger Entry No." := CustLedgEntry."Entry No.";            OnPostCustOnBeforeCopyFromCustLedgEntry(CVLedgEntryBuf, GenJournalLine, Cust);            CVLedgEntryBuf.CopyFromCustLedgEntry(CustLedgEntry);            IsHandled := false;            OnPostCustOnBeforeInsertDtldCVLedgEntry(GenJournalLine, TempDtldCVLedgEntryBuf, CVLedgEntryBuf, CustLedgEntry, IsHandled);            if not IsHandled then                TempDtldCVLedgEntryBuf.InsertDtldCVLedgEntry(TempDtldCVLedgEntryBuf, CVLedgEntryBuf, true);            CVLedgEntryBuf.Open := CVLedgEntryBuf."Remaining Amount" <> 0;            CVLedgEntryBuf.Positive := CVLedgEntryBuf."Remaining Amount" > 0;            OnPostCustOnAfterCopyCVLedgEntryBuf(CVLedgEntryBuf, GenJournalLine, Cust, CustLedgEntry, TempDtldCVLedgEntryBuf);            CalcPmtDiscPossible(GenJournalLine, CVLedgEntryBuf);            if GenJournalLine."Currency Code" <> '' then begin                GenJournalLine.TestField("Currency Factor");                CVLedgEntryBuf."Original Currency Factor" := GenJournalLine."Currency Factor"            end else                CVLedgEntryBuf."Original Currency Factor" := 1;            CVLedgEntryBuf."Adjusted Currency Factor" := CVLedgEntryBuf."Original Currency Factor";            OnPostCustOnAfterAssignCurrencyFactors(CVLedgEntryBuf, GenJournalLine);            // Check the document no.            if GenJournalLine."Recurring Method" = GenJournalLine."Recurring Method"::" " then begin                ShouldCheckDocNo := IsNotPayment(GenJournalLine."Document Type");                OnPostCustOnAfterCalcShouldCheckDocNo(GenJournalLine, ShouldCheckDocNo);                if ShouldCheckDocNo then begin                    GenJnlCheckLine.CheckSalesDocNoIsNotUsed(GenJournalLine);                    CheckSalesExtDocNo(GenJournalLine);                end;            end;            // Post application            ApplyCustLedgEntry(CVLedgEntryBuf, TempDtldCVLedgEntryBuf, GenJournalLine, Cust);            // Post customer entry            CustLedgEntry.CopyFromCVLedgEntryBuffer(CVLedgEntryBuf);            IsHandled := false;            OnPostCustOnBeforeResetCustLedgerEntryAppliesToFields(CustLedgEntry, IsHandled);            if not IsHandled then begin                CustLedgEntry."Amount to Apply" := 0;                CustLedgEntry."Applies-to Doc. No." := '';                CustLedgEntry."Applies-to ID" := '';            end;            if SalesSetup."Copy Customer Name to Entries" then                CustLedgEntry."Customer Name" := Cust.Name;            CustLedgEntry."G/L Register No." := GLReg."No.";            CustLedgEntry.TestField("G/L Register No.");            OnBeforeCustLedgEntryInsert(CustLedgEntry, GenJournalLine, GLReg, TempDtldCVLedgEntryBuf, NextEntryNo);            CustLedgEntry.Insert(true);            CustLedgEntry.CopyLinks(GenJournalLine);            // Post detailed customer entries            DtldLedgEntryInserted := PostDtldCustLedgEntries(GenJournalLine, TempDtldCVLedgEntryBuf, CustPostingGr, true);            OnAfterCustLedgEntryInsert(CustLedgEntry, GenJournalLine, DtldLedgEntryInserted, PreviewMode);            // Post Reminder Terms - Note About Line Fee on Report            LineFeeNoteOnReportHist.Save(CustLedgEntry);            if DtldLedgEntryInserted then                if IsTempGLEntryBufEmpty() then                    DtldCustLedgEntry.SetZeroTransNo(NextTransactionNo);            DeferralPosting(GenJournalLine."Deferral Code", GenJournalLine."Source Code", ReceivablesAccount, GenJournalLine, Balancing);            OnMoveGenJournalLine(GenJournalLine, CustLedgEntry.RecordId);        end;        OnAfterPostCust(GenJournalLine, Balancing, TempGLEntryBuf, NextEntryNo, NextTransactionNo);    end;    local procedure PostVend(var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean)    var        Vend: Record Vendor;        VendPostingGr: Record "Vendor Posting Group";        VendLedgEntry: Record "Vendor Ledger Entry";        CVLedgEntryBuf: Record "CV Ledger Entry Buffer";        TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary;        DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry";        PurchSetup: Record "Purchases & Payables Setup";        PayablesAccount: Code[20];        DtldLedgEntryInserted: Boolean;        CheckExtDocNoHandled: Boolean;        TaxAmount: Decimal;        TaxAmountLCY: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostVend(GenJournalLine, IsHandled);        if IsHandled then            exit;        PurchSetup.Get();        Vend.Get(GenJournalLine."Account No.");        Vend.CheckBlockedVendOnJnls(Vend, GenJournalLine."Document Type", true);        Vend.TestField("Vendor Posting Group");        if GenJournalLine."Posting Group" = '' then            GenJournalLine."Posting Group" := Vend."Vendor Posting Group"        else            if GenJournalLine."Posting Group" <> Vend."Vendor Posting Group" then                Vend.CheckAllowMultiplePostingGroups();        GetVendorPostingGroup(GenJournalLine, VendPostingGr);        IsHandled := false;        OnPostVendOnBeforeGetVendorPayablesAccount(GenJournalLine, VendPostingGr, VendPostingGr."Payables Account", IsHandled);        if not IsHandled then            PayablesAccount := GetVendorPayablesAccount(GenJournalLine, VendPostingGr);        OnPostVendOnAfterAssignPayablesAccount(GenJournalLine, VendPostingGr, PayablesAccount);        DtldVendLedgEntry.LockTable();        VendLedgEntry.LockTable();        OnPostVendOnBeforeInitVendLedgEntry(GenJournalLine, VendLedgEntry, CVLedgEntryBuf, TempDtldCVLedgEntryBuf, VendPostingGr);        InitVendLedgEntry(GenJournalLine, VendLedgEntry);        OnPostVendOnAfterInitVendLedgEntry(GenJournalLine, VendLedgEntry, Vend, TaxAmount, TaxAmountLCY);        if not Vend."Block Payment Tolerance" then            CalcPmtTolerancePossible(                GenJournalLine, VendLedgEntry."Pmt. Discount Date", VendLedgEntry."Pmt. Disc. Tolerance Date",                VendLedgEntry."Max. Payment Tolerance");        TempDtldCVLedgEntryBuf.DeleteAll();        TempDtldCVLedgEntryBuf.Init();        OnPostVendOnBeforeCopyCVLedgEntryBuf(CVLedgEntryBuf, GenJournalLine, Vend);        TempDtldCVLedgEntryBuf.CopyFromGenJnlLine(GenJournalLine);        TempDtldCVLedgEntryBuf."CV Ledger Entry No." := VendLedgEntry."Entry No.";        OnPostVendAfterTempDtldCVLedgEntryBufInit(GenJournalLine, TempDtldCVLedgEntryBuf, TaxAmount, TaxAmountLCY);        CVLedgEntryBuf.CopyFromVendLedgEntry(VendLedgEntry);        TempDtldCVLedgEntryBuf.InsertDtldCVLedgEntry(TempDtldCVLedgEntryBuf, CVLedgEntryBuf, true);        CVLedgEntryBuf.Open := CVLedgEntryBuf."Remaining Amount" <> 0;        CVLedgEntryBuf.Positive := CVLedgEntryBuf."Remaining Amount" > 0;        OnPostVendOnAfterCopyCVLedgEntryBuf(CVLedgEntryBuf, GenJournalLine);        CalcPmtDiscPossible(GenJournalLine, CVLedgEntryBuf);        if GenJournalLine."Currency Code" <> '' then begin            GenJournalLine.TestField("Currency Factor");            CVLedgEntryBuf."Adjusted Currency Factor" := GenJournalLine."Currency Factor"        end else            CVLedgEntryBuf."Adjusted Currency Factor" := 1;        CVLedgEntryBuf."Original Currency Factor" := CVLedgEntryBuf."Adjusted Currency Factor";        OnPostVendOnAfterAssignCurrencyFactors(CVLedgEntryBuf, GenJournalLine);        // Check the document no.        if GenJournalLine."Recurring Method" = GenJournalLine."Recurring Method"::" " then            if IsNotPayment(GenJournalLine."Document Type") then begin                GenJnlCheckLine.CheckPurchDocNoIsNotUsed(GenJournalLine);                OnBeforeCheckPurchExtDocNo(GenJournalLine, VendLedgEntry, CVLedgEntryBuf, CheckExtDocNoHandled);                if not CheckExtDocNoHandled then                    CheckPurchExtDocNo(GenJournalLine);            end;        // Post application        ApplyVendLedgEntry(CVLedgEntryBuf, TempDtldCVLedgEntryBuf, GenJournalLine, Vend);        // Post vendor entry        VendLedgEntry.CopyFromCVLedgEntryBuffer(CVLedgEntryBuf);        VendLedgEntry."Amount to Apply" := 0;        VendLedgEntry."Applies-to Doc. No." := '';        VendLedgEntry."Applies-to ID" := '';        if PurchSetup."Copy Vendor Name to Entries" then            VendLedgEntry."Vendor Name" := Vend.Name;        VendLedgEntry."G/L Register No." := GLReg."No.";        VendLedgEntry.TestField("G/L Register No.");        OnBeforeVendLedgEntryInsert(VendLedgEntry, GenJournalLine, GLReg);        VendLedgEntry.Insert(true);        VendLedgEntry.CopyLinks(GenJournalLine);        // Post detailed vendor entries        OnPostVendOnBeforePostDtldVendLedgEntries(VendLedgEntry, GenJournalLine, TempDtldCVLedgEntryBuf, NextEntryNo);        DtldLedgEntryInserted := PostDtldVendLedgEntries(GenJournalLine, TempDtldCVLedgEntryBuf, VendPostingGr, true);        OnAfterVendLedgEntryInsert(VendLedgEntry, GenJournalLine, DtldLedgEntryInserted, PreviewMode);        if DtldLedgEntryInserted then            if IsTempGLEntryBufEmpty() then                DtldVendLedgEntry.SetZeroTransNo(NextTransactionNo);        OnBeforePostingDeferral(GenJournalLine, VendLedgEntry, TaxAmount, TaxAmountLCY, NextTransactionNo, NextTaxEntryNo, IsHandled);        DeferralPosting(GenJournalLine."Deferral Code", GenJournalLine."Source Code", PayablesAccount, GenJournalLine, Balancing);        // With transactions having FCY with Unrealized VAT, total balance amount was losing fractions with rounding amount.        // Hence it is important to post with the amount on Vendor ledger entry so that it does not skip any VAT entry at the time of posting Unrealized VAT on Vendors        CheckPostUnrealizedVAT(GenJournalLine, false);        OnMoveGenJournalLine(GenJournalLine, VendLedgEntry.RecordId);        OnAfterPostVend(GenJournalLine, Balancing, TempGLEntryBuf, NextEntryNo, NextTransactionNo);    end;    local procedure PostEmployee(GenJnlLine: Record "Gen. Journal Line")    var        Employee: Record Employee;        EmployeePostingGr: Record "Employee Posting Group";        EmployeeLedgerEntry: Record "Employee Ledger Entry";        CVLedgEntryBuf: Record "CV Ledger Entry Buffer";        TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary;        DtldEmplLedgEntry: Record "Detailed Employee Ledger Entry";        TaxAmount: Decimal;        TaxBaseAmount: Decimal;        DtldLedgEntryInserted: Boolean;    begin        Employee.Get(GenJnlLine."Account No.");        Employee.CheckBlockedEmployeeOnJnls(true);        Employee.TestField("Employee Posting Group");        if GenJnlLine."Posting Group" = '' then            GenJnlLine."Posting Group" := Employee."Employee Posting Group"        else            if GenJnlLine."Posting Group" <> Employee."Employee Posting Group" then                Employee.CheckAllowMultiplePostingGroups();        EmployeePostingGr.Get(GenJnlLine."Posting Group");        DtldEmplLedgEntry.LockTable();        EmployeeLedgerEntry.LockTable();        InitEmployeeLedgerEntry(GenJnlLine, EmployeeLedgerEntry);        OnPostEmployeeOnAfterInitEmployeeLedgerEntry(GenJnlLine, EmployeeLedgerEntry, Employee, TaxAmount, TaxBaseAmount);        TempDtldCVLedgEntryBuf.DeleteAll();        TempDtldCVLedgEntryBuf.Init();        TempDtldCVLedgEntryBuf.CopyFromGenJnlLine(GenJnlLine);        TempDtldCVLedgEntryBuf."CV Ledger Entry No." := EmployeeLedgerEntry."Entry No.";        OnPostEmployeeAfterTempDtldCVLedgEntryBufInit(GenJnlLine, TempDtldCVLedgEntryBuf, TaxAmount, TaxBaseAmount);        CVLedgEntryBuf.CopyFromEmplLedgEntry(EmployeeLedgerEntry);        TempDtldCVLedgEntryBuf.InsertDtldCVLedgEntry(TempDtldCVLedgEntryBuf, CVLedgEntryBuf, true);        CVLedgEntryBuf.Open := CVLedgEntryBuf."Remaining Amount" <> 0;        CVLedgEntryBuf.Positive := CVLedgEntryBuf."Remaining Amount" > 0;        OnPostEmployeeOnAfterCopyCVLedgEntryBuf(CVLedgEntryBuf, GenJnlLine);        if GenJnlLine."Currency Code" <> '' then begin            GenJnlLine.TestField("Currency Factor");            CVLedgEntryBuf."Adjusted Currency Factor" := GenJnlLine."Currency Factor"        end else            CVLedgEntryBuf."Adjusted Currency Factor" := 1;        CVLedgEntryBuf."Original Currency Factor" := CVLedgEntryBuf."Adjusted Currency Factor";        OnPostEmployeeOnAfterAssignCurrencyFactors(CVLedgEntryBuf, GenJnlLine);        // Post application        ApplyEmplLedgEntry(CVLedgEntryBuf, TempDtldCVLedgEntryBuf, GenJnlLine, Employee);        // Post employee entry        EmployeeLedgerEntry.CopyFromCVLedgEntryBuffer(CVLedgEntryBuf);        EmployeeLedgerEntry."Amount to Apply" := 0;        EmployeeLedgerEntry."Applies-to Doc. No." := '';        EmployeeLedgerEntry."Applies-to ID" := '';        EmployeeLedgerEntry."G/L Register No." := GLReg."No.";        EmployeeLedgerEntry.TestField("G/L Register No.");        OnPostEmployeeOnBeforeEmployeeLedgerEntryInsert(GenJnlLine, EmployeeLedgerEntry, GLReg);        EmployeeLedgerEntry.Insert(true);        EmployeeLedgerEntry.CopyLinks(GenJnlLine);        // Post detailed employee entries        DtldLedgEntryInserted := PostDtldEmplLedgEntries(GenJnlLine, TempDtldCVLedgEntryBuf, EmployeePostingGr, true);        OnPostEmployeeOnAfterPostDtldEmplLedgEntries(GenJnlLine, EmployeeLedgerEntry, DtldLedgEntryInserted);        // Posting GL Entry        if DtldLedgEntryInserted then            if IsTempGLEntryBufEmpty() then                DtldEmplLedgEntry.SetZeroTransNo(NextTransactionNo);        OnAfterPostEmployee(GenJnlLine, EmployeeLedgerEntry, TaxAmount, TaxBaseAmount, NextTransactionNo, NextTaxEntryNo);        OnMoveGenJournalLine(GenJnlLine, EmployeeLedgerEntry.RecordId);    end;    local procedure PostBankAcc(var GenJnlLine: Record "Gen. Journal Line"; Balancing: Boolean)    var        BankAcc: Record "Bank Account";        BankAccLedgEntry: Record "Bank Account Ledger Entry";        CheckLedgEntry: Record "Check Ledger Entry";        CheckLedgEntry2: Record "Check Ledger Entry";        BankAccPostingGr: Record "Bank Account Posting Group";        TaxAmount: Decimal;        TaxAmountLCY: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostBankAcc(GenJnlLine, IsHandled);        if IsHandled then            exit;        BankAcc.Get(GenJnlLine."Account No.");        BankAcc.TestField(Blocked, false);        IsHandled := false;        OnPostBankAccOnBeforeCheckCurrencyCode(GenJnlLine, BankAcc, IsHandled);        if not IsHandled then            if GenJnlLine."Currency Code" = '' then                BankAcc.TestField("Currency Code", '')            else                if BankAcc."Currency Code" <> '' then                    GenJnlLine.TestField("Currency Code", BankAcc."Currency Code");        IsHandled := false;        OnBeforeCheckBankAccPostingGroup(GLSetup, GenJnlLine, IsHandled);        if not IsHandled then begin            BankAcc.TestField("Bank Acc. Posting Group");            BankAccPostingGr.Get(BankAcc."Bank Acc. Posting Group");        end;        BankAccLedgEntry.LockTable();        OnPostBankAccOnBeforeInitBankAccLedgEntry(GenJnlLine, CurrencyFactor, NextEntryNo, NextTransactionNo, BankAccPostingGr, TaxAmount, TaxAmountLCY);        InitBankAccLedgEntry(GenJnlLine, BankAccLedgEntry);        BankAccLedgEntry."Bank Acc. Posting Group" := BankAcc."Bank Acc. Posting Group";        BankAccLedgEntry."Currency Code" := BankAcc."Currency Code";        if BankAcc."Currency Code" <> '' then            BankAccLedgEntry.Amount := GenJnlLine.Amount        else            BankAccLedgEntry.Amount := GenJnlLine."Amount (LCY)";        BankAccLedgEntry."Amount (LCY)" := GenJnlLine."Amount (LCY)";        OnBeforeBankAccLedgEntryUpdateAmounts(BankAccLedgEntry, GenJnlLine, BankAcc, TaxAmount, TaxAmountLCY);        BankAccLedgEntry.Open := GenJnlLine.Amount <> 0;        if not BankAccLedgEntry.Open then begin            BankAccLedgEntry."Closed at Date" := GenJnlLine."Posting Date";            BankAccLedgEntry."Statement Status" := BankAccLedgEntry."Statement Status"::Closed;        end;        BankAccLedgEntry."Remaining Amount" := BankAccLedgEntry.Amount;        BankAccLedgEntry.Positive := GenJnlLine.Amount > 0;        BankAccLedgEntry.UpdateDebitCredit(GenJnlLine.Correction);        OnPostBankAccOnBeforeBankAccLedgEntryInsert(BankAccLedgEntry, GenJnlLine, BankAcc, TempGLEntryBuf, NextTransactionNo, GLReg, Balancing);        BankAccLedgEntry.Insert(true);        OnPostBankAccOnAfterBankAccLedgEntryInsert(BankAccLedgEntry, GenJnlLine, BankAcc);        BankAccLedgEntry.CopyLinks(GenJnlLine);        if ((GenJnlLine.Amount <= 0) and (GenJnlLine."Bank Payment Type" = GenJnlLine."Bank Payment Type"::"Computer Check") and GenJnlLine."Check Printed") or           ((GenJnlLine.Amount < 0) and (GenJnlLine."Bank Payment Type" = GenJnlLine."Bank Payment Type"::"Manual Check"))        then begin            IsHandled := false;            OnPostBankAccOnBeforeModifyCheckLedgerEntry(GenJnlLine, IsHandled);            if not IsHandled then                if BankAcc."Currency Code" <> GenJnlLine."Currency Code" then                    Error(BankPaymentTypeMustNotBeFilledErr);            case GenJnlLine."Bank Payment Type" of                GenJnlLine."Bank Payment Type"::"Computer Check":                    begin                        GenJnlLine.TestField("Check Printed", true);                        CheckLedgEntry.LockTable();                        CheckLedgEntry.Reset();                        CheckLedgEntry.SetCurrentKey("Bank Account No.", "Entry Status", "Check No.");                        CheckLedgEntry.SetRange("Bank Account No.", GenJnlLine."Account No.");                        CheckLedgEntry.SetRange("Entry Status", CheckLedgEntry."Entry Status"::Printed);                        CheckLedgEntry.SetRange("Check No.", GenJnlLine."Document No.");                        OnPostBankAccOnAfterCheckLedgEntrySetFilters(CheckLedgEntry, GenJnlLine);                        if CheckLedgEntry.FindSet() then                            repeat                                CheckLedgEntry2 := CheckLedgEntry;                                CheckLedgEntry2."Entry Status" := CheckLedgEntry2."Entry Status"::Posted;                                CheckLedgEntry2."Bank Account Ledger Entry No." := BankAccLedgEntry."Entry No.";                                OnPostBankAccOnBeforeCheckLedgEntry2Modify(CheckLedgEntry, BankAccLedgEntry, CheckLedgEntry2);                                CheckLedgEntry2.Modify();                            until CheckLedgEntry.Next() = 0;                    end;                GenJnlLine."Bank Payment Type"::"Manual Check":                    begin                        if GenJnlLine."Document No." = '' then                            Error(DocNoMustBeEnteredErr, GenJnlLine."Bank Payment Type");                        CheckLedgEntry.Reset();                        if NextCheckEntryNo = 0 then begin                            CheckLedgEntry.LockTable();                            if CheckLedgEntry.FindLast() then                                NextCheckEntryNo := CheckLedgEntry."Entry No." + 1                            else                                NextCheckEntryNo := 1;                        end;                        CheckLedgEntry.SetRange("Bank Account No.", GenJnlLine."Account No.");                        CheckLedgEntry.SetFilter(                          "Entry Status", '%1|%2|%3',                          CheckLedgEntry."Entry Status"::Printed,                          CheckLedgEntry."Entry Status"::Posted,                          CheckLedgEntry."Entry Status"::"Financially Voided");                        CheckLedgEntry.SetRange("Check No.", GenJnlLine."Document No.");                        if not CheckLedgEntry.IsEmpty() then                            Error(CheckAlreadyExistsErr, GenJnlLine."Document No.");                        InitCheckLedgEntry(BankAccLedgEntry, CheckLedgEntry);                        CheckLedgEntry."Bank Payment Type" := CheckLedgEntry."Bank Payment Type"::"Manual Check";                        if BankAcc."Currency Code" <> '' then                            CheckLedgEntry.Amount := -GenJnlLine.Amount                        else                            CheckLedgEntry.Amount := -GenJnlLine."Amount (LCY)";                        OnPostBankAccOnBeforeCheckLedgEntryInsert(CheckLedgEntry, BankAccLedgEntry, GenJnlLine, BankAcc, TaxAmount, TaxAmountLCY);                        CheckLedgEntry.Insert(true);                        OnPostBankAccOnAfterCheckLedgEntryInsert(CheckLedgEntry, BankAccLedgEntry, GenJnlLine, BankAcc);                        NextCheckEntryNo := NextCheckEntryNo + 1;                    end;            end;        end;        IsHandled := false;        OnPostBankAccOnCheckingBankAccPostingGrGLAccountNo(GenJnlLine, BankAccPostingGr, IsHandled);        if not IsHandled then            BankAccPostingGr.TestField("G/L Account No.");        IsHandled := false;        OnPostBankAccOnBeforeCreateGLEntryBalAcc(GenJnlLine, BankAccPostingGr, BankAcc, NextEntryNo, IsHandled, TaxAmount, TaxAmountLCY);        if not IsHandled then            CreateGLEntryBalAcc(              GenJnlLine, BankAccPostingGr."G/L Account No.", GenJnlLine."Amount (LCY)", GenJnlLine."Source Currency Amount",              GenJnlLine."Bal. Account Type", GenJnlLine."Bal. Account No.");        DeferralPosting(GenJnlLine."Deferral Code", GenJnlLine."Source Code", BankAccPostingGr."G/L Account No.", GenJnlLine, Balancing);        OnMoveGenJournalLine(GenJnlLine, BankAccLedgEntry.RecordId);        OnAfterPostBankAcc(GenJnlLine, Balancing, TempGLEntryBuf, NextEntryNo, NextTransactionNo);    end;    local procedure PostFixedAsset(GenJnlLine: Record "Gen. Journal Line")    var        GLEntry: Record "G/L Entry";        GLEntry2: Record "G/L Entry";        TempFAGLPostBuf: Record "FA G/L Posting Buffer" temporary;        FAGLPostBuf: Record "FA G/L Posting Buffer";        VATPostingSetup: Record "VAT Posting Setup";        FAAutomaticEntry: Codeunit "FA Automatic Entry";        ShortcutDim1Code: Code[20];        ShortcutDim2Code: Code[20];        OriginalGLAccNo: Code[20];        Correction2: Boolean;        NetDisposalNo: Integer;        DimensionSetID: Integer;        VATEntryGLEntryNo: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostFixedAsset(GenJnlLine, IsHandled);        if not IsHandled then begin            InitGLEntry(                GenJnlLine, GLEntry, '', GenJnlLine."Amount (LCY)", GenJnlLine."Source Currency Amount", true, GenJnlLine."System-Created Entry",                CalcAmountSrcCurr(GenJnlLine, GenJnlLine."Amount (LCY)"));            GLEntry."Gen. Posting Type" := GenJnlLine."Gen. Posting Type";            GLEntry."Bal. Account Type" := GenJnlLine."Bal. Account Type";            GLEntry."Bal. Account No." := GenJnlLine."Bal. Account No.";            InitVAT(GenJnlLine, GLEntry, VATPostingSetup);            GLEntry2 := GLEntry;            IsHandled := false;            OnPostFixedAssetOnBeforeGenJnlPostLine(GenJnlLine, GLEntry2, NextTransactionNo, NextEntryNo, GLReg, IsHandled);            if not IsHandled then                FAJnlPostLine.GenJnlPostLine(                    GenJnlLine, GLEntry2.Amount, GLEntry2."VAT Amount", NextTransactionNo, NextEntryNo, GLReg."No.");            CreateAndPostDerogEntry(GenJnlLine);            ShortcutDim1Code := GenJnlLine."Shortcut Dimension 1 Code";            ShortcutDim2Code := GenJnlLine."Shortcut Dimension 2 Code";            DimensionSetID := GenJnlLine."Dimension Set ID";            Correction2 := GenJnlLine.Correction;            OnPostFixedAssetOnAfterSaveGenJnlLineValues(GenJnlLine);            VATEntryGLEntryNo := 0;            if FAJnlPostLine.FindFirstGLAcc(TempFAGLPostBuf) then                repeat                    GenJnlLine."Shortcut Dimension 1 Code" := TempFAGLPostBuf."Global Dimension 1 Code";                    GenJnlLine."Shortcut Dimension 2 Code" := TempFAGLPostBuf."Global Dimension 2 Code";                    GenJnlLine."Dimension Set ID" := TempFAGLPostBuf."Dimension Set ID";                    GenJnlLine.Correction := TempFAGLPostBuf.Correction;                    OnPostFixedAssetOnBeforeInitGLEntryFromTempFAGLPostBuf(GenJnlLine, TempFAGLPostBuf);                    FADimAlreadyChecked := TempFAGLPostBuf."FA Posting Group" <> '';                    CheckDimValueForDisposal(GenJnlLine, TempFAGLPostBuf."Account No.");                    if TempFAGLPostBuf."Original General Journal Line" then begin                        InitGLEntry(                            GenJnlLine, GLEntry, TempFAGLPostBuf."Account No.", TempFAGLPostBuf.Amount, GLEntry2."Additional-Currency Amount", true, true,                            CalcAmountSrcCurr(GenJnlLine, TempFAGLPostBuf.Amount));                        OriginalGLAccNo := TempFAGLPostBuf."Account No.";                    end else begin                        CheckNonAddCurrCodeOccurred('');                        InitGLEntry(                            GenJnlLine, GLEntry, TempFAGLPostBuf."Account No.", TempFAGLPostBuf.Amount, 0, false, true,                            CalcAmountSrcCurr(GenJnlLine, TempFAGLPostBuf.Amount));                    end;                    FADimAlreadyChecked := false;                    GLEntry.CopyPostingGroupsFromGLEntry(GLEntry2);                    GLEntry."VAT Amount" := GLEntry2."VAT Amount";                    GLEntry."Bal. Account Type" := GLEntry2."Bal. Account Type";                    GLEntry."Bal. Account No." := GLEntry2."Bal. Account No.";                    GLEntry."FA Entry Type" := TempFAGLPostBuf."FA Entry Type";                    GLEntry."FA Entry No." := TempFAGLPostBuf."FA Entry No.";                    if TempFAGLPostBuf."Net Disposal" then                        NetDisposalNo := NetDisposalNo + 1                    else                        NetDisposalNo := 0;                    if TempFAGLPostBuf."Automatic Entry" and not TempFAGLPostBuf."Net Disposal" then                        FAAutomaticEntry.AdjustGLEntry(GLEntry);                    if NetDisposalNo > 1 then                        GLEntry."VAT Amount" := 0;                    if TempFAGLPostBuf."FA Posting Group" <> '' then begin                        FAGLPostBuf := TempFAGLPostBuf;                        FAGLPostBuf."Entry No." := NextEntryNo;                        FAGLPostBuf.Insert();                    end;                    IsHandled := false;                    OnPostFixedAssetOnBeforeInsertGLEntry(GenJnlLine, GLEntry, IsHandled, TempFAGLPostBuf, GLEntry2, NextEntryNo, TempGLEntryVATEntryLink);                    if not IsHandled then                        InsertGLEntry(GenJnlLine, GLEntry, true);                    if (VATEntryGLEntryNo = 0) and (GLEntry."Gen. Posting Type" <> GLEntry."Gen. Posting Type"::" ") then                        VATEntryGLEntryNo := GLEntry."Entry No.";                until FAJnlPostLine.GetNextGLAcc(TempFAGLPostBuf) = 0;            GenJnlLine."Shortcut Dimension 1 Code" := ShortcutDim1Code;            GenJnlLine."Shortcut Dimension 2 Code" := ShortcutDim2Code;            OnPostFixedAssetOnAfterSetGenJnlLineShortcutDimCodes(GenJnlLine);            GenJnlLine."Dimension Set ID" := DimensionSetID;            GenJnlLine.Correction := Correction2;            GenJnlLine."FA G/L Account No." := OriginalGLAccNo;            if GenJnlLine."FA G/L Account No." = '' then                GenJnlLine."FA G/L Account No." := GLEntry."G/L Account No.";            OnPostFixedAssetOnBeforeAssignGLEntry(GenJnlLine, GLEntry, GLEntry2);            GLEntry := GLEntry2;            if VATEntryGLEntryNo = 0 then                VATEntryGLEntryNo := GLEntry."Entry No.";            TempGLEntryBuf."Entry No." := VATEntryGLEntryNo; // Used later in InsertVAT(): GLEntryVATEntryLink.InsertLink(TempGLEntryBuf."Entry No.",VATEntry."Entry No.")            OnPostFixedAssetOnBeforePostVAT(GenJnlLine);            PostVAT(GenJnlLine, GLEntry, VATPostingSetup);            FAJnlPostLine.UpdateRegNo(GLReg."No.");        end;        OnMoveGenJournalLine(GenJnlLine, GLEntry.RecordId);        OnAfterPostFixedAsset(GenJnlLine, TempGLEntryVATEntryLink);    end;    /// <summary>    /// Wrapper procedure for external call of PostFixedAssetPostFixedAsset, which is used for posting a Gen. Journal Line with Account Type Fixed Asset.    /// G/L Entries, VAT Entries and FA Ledger Entries are created.    /// </summary>    /// <remarks>    /// In the procedure there is no check if Account Type is Fixed Asset.    /// </remarks>    /// <param name="GenJnlLine">General Journal Line that is being posted.</param>    procedure RunPostFixedAsset(GenJnlLine: Record "Gen. Journal Line")    begin        // Wrapper procedure for exetrrnal call of PostFixedAsset        PostFixedAsset(GenJnlLine);    end;    local procedure PostICPartner(GenJnlLine: Record "Gen. Journal Line")    var        ICPartner: Record "IC Partner";        AccountNo: Code[20];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostICPartner(GenJnlLine, IsHandled);        if IsHandled then            exit;        if GenJnlLine."Account No." <> ICPartner.Code then            ICPartner.Get(GenJnlLine."Account No.");        if (GenJnlLine."Document Type" = GenJnlLine."Document Type"::"Credit Memo") xor (GenJnlLine.Amount > 0) then begin            ICPartner.TestField("Receivables Account");            AccountNo := ICPartner."Receivables Account";        end else begin            ICPartner.TestField("Payables Account");            AccountNo := ICPartner."Payables Account";        end;        IsHandled := false;        OnPostICPartnerOnBeforeCreateGLEntryBalAcc(GenJnlLine, NextEntryNo, IsHandled);        if not IsHandled then            CreateGLEntryBalAcc(              GenJnlLine, AccountNo, GenJnlLine."Amount (LCY)", GenJnlLine."Source Currency Amount",              GenJnlLine."Bal. Account Type", GenJnlLine."Bal. Account No.");    end;    local procedure FindJobLineSign(GenJnlLine: Record "Gen. Journal Line")    begin        JobLine := (GenJnlLine."Job No." <> '');        OnAfterFindJobLineSign(GenJnlLine, JobLine);    end;    /// <summary>    /// Wrapper procedure for external call of PostJob, which is used for posting a gen. journal line with account type job.    /// G/l entries, job entries, usage related ledger entries (resourse or item and value), possibly warehouse entries are created.    /// </summary>    /// <remarks>    /// Procedure should not be called externally.    /// Global variable determining if the gen. journal line is related to the job is set in the procedure.    /// </remarks>    /// <param name="GenJnlLine">Gen. journal line that is being posted.</param>    /// <param name="GLEntry">G/l entry created for the gen. journal line.</param>    procedure PostJob(GenJnlLine: Record "Gen. Journal Line"; GLEntry: Record "G/L Entry")    var        JobPostLine: Codeunit "Job Post-Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostJob(GenJnlLine, GLEntry, JobLine, IsHandled);        if IsHandled then            exit;        if JobLine then begin            JobLine := false;            JobPostLine.PostGenJnlLine(GenJnlLine, GLEntry);        end;    end;    /// <summary>    /// Initialize global variables and G/L Register for new posting batch, locks needed tables.    /// </summary>    /// <param name="GenJnlLine">Gen. Journal Line that is being posted.</param>    procedure StartPosting(GenJnlLine: Record "Gen. Journal Line")    var        GenJnlTemplate: Record "Gen. Journal Template";        AccountingPeriodMgt: Codeunit "Accounting Period Mgt.";    begin        OnBeforeStartPosting(GenJnlLine);        InitNextEntryNo();        FirstTransactionNo := NextTransactionNo;        InitLastDocDate(GenJnlLine);        CurrentBalance := 0;        FiscalYearStartDate := AccountingPeriodMgt.GetPeriodStartingDate();        GetGLSetup();        if not GenJnlTemplate.Get(GenJnlLine."Journal Template Name") then            GenJnlTemplate.Init();        OnStartPostingOnBeforeSetNextVatEntryNo(VATEntry);        VATEntry.LockTable();        if VATEntry.FindLast() then            NextVATEntryNo := VATEntry."Entry No." + 1        else            NextVATEntryNo := 1;        OnStartPostingOnAfterSetNextVatEntryNo(VATEntry, NextVATEntryNo);        NextConnectionNo := 1;        FirstNewVATEntryNo := NextVATEntryNo;        OnStartPostingOnAfterSetNextTaxEntryNo(NextTaxEntryNo);        GLReg.LockTable();        if GLReg.FindLast() then            GLReg."No." := GLReg."No." + 1        else            GLReg."No." := 1;        GLReg.Init();        GLReg."From Entry No." := NextEntryNo;        GLReg."From VAT Entry No." := NextVATEntryNo;        GLReg."Source Code" := GenJnlLine."Source Code";        GLReg."Journal Templ. Name" := GenJnlTemplate.Name;        GLReg."Journal Batch Name" := GenJnlLine."Journal Batch Name";        GLReg."User ID" := CopyStr(UserId(), 1, MaxStrLen(GLReg."User ID"));        IsGLRegInserted := false;        OnAfterInitGLRegister(GLReg, GenJnlLine, NextTaxEntryNo, NextEntryNo, NextVATEntryNo, NextTransactionNo);        GetCurrencyExchRate(GenJnlLine);        TempGLEntryBuf.DeleteAll();        TempGLEntryPreview.DeleteAll();        CalculateCurrentBalance(          GenJnlLine."Account No.", GenJnlLine."Bal. Account No.", GenJnlLine.IncludeVATAmount(), GenJnlLine."Amount (LCY)", GenJnlLine."VAT Amount");        OnAfterStartPosting(GenJnlLine);    end;    /// <summary>    /// If new transaction needs to be started, Unrealized VAT is check and posted, global values initialized for the new transaction.     /// Currency is updated for the new Gen. Journal Line that is being posted, current Balance of the posting is updated.    /// </summary>    /// <param name="GenJnlLine">Gen. Journal Line that is being posted.</param>    procedure ContinuePosting(GenJnlLine: Record "Gen. Journal Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeContinuePosting(GenJnlLine, GLReg, NextEntryNo, NextTransactionNo, IsHandled);        if IsHandled then            exit;        if NextTransactionNoNeeded(GenJnlLine) then begin            CheckPostUnrealizedVAT(GenJnlLine, false);            IsHandled := false;            OnContinuePostingOnIncreaseNextTransactionNo(GenJnlLine, NextTransactionNo, IsHandled);            if not IsHandled then                NextTransactionNo := NextTransactionNo + 1;            InitLastDocDate(GenJnlLine);            FirstNewVATEntryNo := NextVATEntryNo;        end;        OnContinuePostingOnBeforeCalculateCurrentBalance(GenJnlLine, NextTransactionNo);        GetCurrencyExchRate(GenJnlLine);        TempGLEntryBuf.DeleteAll();        if not GLEntryInconsistent then            TempGLEntryPreview.DeleteAll();        CalculateCurrentBalance(          GenJnlLine."Account No.", GenJnlLine."Bal. Account No.", GenJnlLine.IncludeVATAmount(),          GenJnlLine."Amount (LCY)", GenJnlLine."VAT Amount");    end;    local procedure NextTransactionNoNeeded(GenJnlLine: Record "Gen. Journal Line"): Boolean    var        LastDocTypeOption: Option;        NewTransaction: Boolean;    begin        NewTransaction :=            (LastDocType <> GenJnlLine."Document Type") or (LastDocNo <> GenJnlLine."Document No.") or            (LastDate <> GenJnlLine."Posting Date") or ((CurrentBalance = 0) and (TotalAddCurrAmount = 0)) and not GenJnlLine."System-Created Entry";        LastDocTypeOption := LastDocType.AsInteger();        OnNextTransactionNoNeeded(GenJnlLine, LastDocTypeOption, LastDocNo, LastDate, CurrentBalance, TotalAddCurrAmount, NewTransaction);        LastDocType := "Gen. Journal Document Type".FromInteger(LastDocTypeOption);        exit(NewTransaction);    end;    [InherentPermissions(PermissionObjectType::TableData, Database::"G/L Entry", 'r')]    [InherentPermissions(PermissionObjectType::TableData, Database::"G/L Transaction", 'r')]    local procedure ValidateSequenceNo(LedgEntryNo: Integer; xLedgEntryNo: Integer; TableNo: Integer)    begin        if LedgEntryNo = xLedgEntryNo then            exit;        if not GLSetup.UseConcurrentPosting() then            exit;        SequenceNoMgt.ValidateSeqNo(TableNo);    end;    /// <summary>    /// Invalidates the transaction-scoped caches in this codeunit so the next call to RunWithCheck    /// is forced through StartPosting (which re-takes the G/L Entry table lock and re-reads the    /// last entry number from disk) instead of taking the ContinuePosting fast path with a stale    /// NextEntryNo.    /// </summary>    procedure ResetTransactionState()    begin        NextEntryNo := 0;        NextTransactionNo := 0;        NextVATEntryNo := 0;        FirstEntryNo := 0;        FirstNewVATEntryNo := 0;        IsGLRegInserted := false;        TempGLEntryBuf.Reset();        TempGLEntryBuf.DeleteAll();    end;    /// <summary>    /// Checks if transaction is balanced for both local and additional currencies, inserts all G/L Entries that were created for the Gen. Journal Line.    /// If posting is performed for application purpose, original Customer and Vendor Ledger Entries are updated to reflect that.    /// Cost journal line is posted if cost accounting setup is setup for this purpose.    /// </summary>    /// <param name="GenJournalLine">Gen. Journal Line that is being posted.</param>    /// <returns>True if balance of the transaction is balanced for both local and additional currencies.</returns>    procedure FinishPosting(GenJournalLine: Record "Gen. Journal Line") IsTransactionConsistent: Boolean    var        CostAccountingSetup: Record "Cost Accounting Setup";        TransferGlEntriesToCA: Codeunit "Transfer GL Entries to CA";        IsTransactionConsistentExternal: Boolean;    begin        OnBeforeFinishPosting(GenJournalLine, TempGLEntryBuf);        IsTransactionConsistent :=          (BalanceCheckAmount = 0) and (BalanceCheckAmount2 = 0) and          (BalanceCheckAddCurrAmount = 0) and (BalanceCheckAddCurrAmount2 = 0) and          (BalanceCheckSrcCurrAmount = 0) and (BalanceCheckSrcCurrAmount2 = 0);        IsTransactionConsistentExternal := IsTransactionConsistent;        GlobalGLEntry.Consistent(IsTransactionConsistent);        OnAfterSettingIsTransactionConsistent(GenJournalLine, IsTransactionConsistentExternal);        IsTransactionConsistent := IsTransactionConsistent and IsTransactionConsistentExternal;        if TempGLEntryBuf.FindSet() then begin            repeat                TempGLEntryPreview := TempGLEntryBuf;                TempGLEntryPreview.Insert();                GlobalGLEntry := TempGLEntryBuf;                if AddCurrencyCode = '' then begin                    GlobalGLEntry."Additional-Currency Amount" := 0;                    GlobalGLEntry."Add.-Currency Debit Amount" := 0;                    GlobalGLEntry."Add.-Currency Credit Amount" := 0;                end;                GlobalGLEntry."Prior-Year Entry" := GlobalGLEntry."Posting Date" < FiscalYearStartDate;                OnBeforeInsertGlobalGLEntry(GlobalGLEntry, GenJournalLine, GLReg, FiscalYearStartDate);                GlobalGLEntry."G/L Register No." := GLReg."No.";                GlobalGLEntry.TestField("G/L Register No.");                GlobalGLEntry.Insert(true);                if GlobalGLEntry."Source Currency Code" <> '' then                    InsertGLAccountSourceCurrency(GlobalGLEntry);                GlobalGLTransaction.InsertFromGLEntry(GlobalGLEntry, GLReg);                OnAfterInsertGlobalGLEntry(GlobalGLEntry, TempGLEntryBuf, NextEntryNo, GenJournalLine);                GlobalGLEntry.CopyLinks(GenJournalLine);                if GenJournalLine."Spend Request No." <> '' then                    UpdateSpendRequest(GlobalGLEntry, GenJournalLine);            until TempGLEntryBuf.Next() = 0;            GLReg."To VAT Entry No." := NextVATEntryNo - 1;            GLReg."To Entry No." := GlobalGLEntry."Entry No.";            UpdateGLReg(IsTransactionConsistent, GenJournalLine);            SetGLAccountNoInVATEntries();        end;        GlobalGLEntry.Consistent(IsTransactionConsistent);        if CostAccountingSetup.Get() then            if CostAccountingSetup."Auto Transfer from G/L" then                TransferGlEntriesToCA.GetGLEntries();        OnFinishPostingOnBeforeResetFirstEntryNo(GlobalGLEntry, NextEntryNo, FirstEntryNo, GenJournalLine);        FirstEntryNo := 0;        if IsTransactionConsistent then            UpdateAppliedCVLedgerEntries();        OnAfterFinishPosting(GlobalGLEntry, GLReg, IsTransactionConsistent, GenJournalLine);    end;    local procedure UpdateGLReg(IsTransactionConsistent: Boolean; var GenJnlLine: Record "Gen. Journal Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateGLReg(IsTransactionConsistent, IsGLRegInserted, GLReg, IsHandled, GenJnlLine, GlobalGLEntry, FirstNewVATEntryNo, NextTaxEntryNo);        if IsHandled then            exit;        if IsTransactionConsistent then            if IsGLRegInserted then                GLReg.Modify()            else begin                GLReg.Insert();                IsGLRegInserted := true;            end;    end;    local procedure UpdateAppliedCVLedgerEntries()    var        VendorLedgerEntryApplied: Record "Vendor Ledger Entry";        CustLedgEntryApplied: Record "Cust. Ledger Entry";    begin        if TempVendorLedgerEntry.FindSet() then begin            repeat                if VendorLedgerEntryApplied.Get(TempVendorLedgerEntry."Entry No.") then begin                    VendorLedgerEntryApplied."Applies-to ID" := '';                    VendorLedgerEntryApplied."Amount to Apply" := 0;                    VendorLedgerEntryApplied.Modify();                end;            until TempVendorLedgerEntry.Next() = 0;            TempVendorLedgerEntry.DeleteAll();        end;        if TempCustLedgEntry.FindSet() then begin            repeat                if CustLedgEntryApplied.Get(TempCustLedgEntry."Entry No.") then begin                    CustLedgEntryApplied."Applies-to ID" := '';                    CustLedgEntryApplied."Amount to Apply" := 0;                    CustLedgEntryApplied.Modify();                end;            until TempCustLedgEntry.Next() = 0;            TempCustLedgEntry.DeleteAll();        end;    end;    local procedure UpdateSpendRequest(var GLEntry: Record "G/L Entry"; var GenJnlLine: Record "Gen. Journal Line")    var        SpendReqToGLLink: Record "Spend Request To G/L Link";        SpendRequest: Record "Spend Request";        SpendRequestDetail: Record "Spend Request Detail";    begin        if GenJnlLine."Spend Request No." = '' then            exit;        // we only record the expense side (positive amounts), unless it's a correction        if not GenJnlLine.Correction and (GLEntry.Amount < 0) then            exit;        SpendRequestDetail.SetLoadFields("Line No.");        SpendRequestDetail.SetRange("Spend Request No.", GenJnlLine."Spend Request No.");        SpendRequestDetail.SetRange("G/L Account No.", GLEntry."G/L Account No.");        if SpendRequestDetail.FindFirst() then;        SpendReqToGLLink.Init();        SpendReqToGLLink."Spend Request No." := GenJnlLine."Spend Request No.";        SpendReqToGLLink."Spend Request Detail No." := SpendRequestDetail."Line No.";        SpendReqToGLLink."G/L Entry No." := GLEntry."Entry No.";        SpendReqToGLLink."G/L Account No." := GLEntry."G/L Account No.";        SpendReqToGLLink."Document No." := GLEntry."Document No.";        SpendReqToGLLink."Posting Date" := GLEntry."Posting Date";        SpendReqToGLLink.Amount := GLEntry.Amount;        SpendReqToGLLink.Insert();        if GenJnlLine."Spend Request Close" then begin            SpendRequest.ReadIsolation(IsolationLevel::UpdLock);            SpendRequest.Get(GenJnlLine."Spend Request No.");            if SpendRequest.Status = SpendRequest.Status::Approved then begin                SpendRequest.Status := SpendRequest.Status::Closed;                SpendRequest."Closed At" := CurrentDateTime();                SpendRequest."Closed By Document No." := GLEntry."Document No.";                SpendRequest.Modify();            end;        end;    end;    local procedure InsertGLAccountSourceCurrency(var GLEntry: Record "G/L Entry")    var        GLAccountSourceCurrency: Record "G/L Account Source Currency";    begin        if not GLAccountSourceCurrency.Get(GLEntry."G/L Account No.", GLEntry."Source Currency Code") then begin            GLAccountSourceCurrency.Init();            GLAccountSourceCurrency."G/L Account No." := GLEntry."G/L Account No.";            GLAccountSourceCurrency."Currency Code" := GLEntry."Source Currency Code";            GLAccountSourceCurrency.Insert();        end;    end;    local procedure PostUnrealizedVAT(GenJnlLine: Record "Gen. Journal Line")    begin        if CheckUnrealizedCust then begin            CustUnrealizedVAT(GenJnlLine, UnrealizedCustLedgEntry, UnrealizedRemainingAmountCust);            CheckUnrealizedCust := false;        end;        if CheckUnrealizedVend then begin            VendUnrealizedVAT(GenJnlLine, UnrealizedVendLedgEntry, UnrealizedRemainingAmountVend);            CheckUnrealizedVend := false;        end;    end;    local procedure CheckPostUnrealizedVAT(GenJnlLine: Record "Gen. Journal Line"; CheckCurrentBalance: Boolean)    begin        if CheckCurrentBalance and (CurrentBalance = 0) or not CheckCurrentBalance then            PostUnrealizedVAT(GenJnlLine)    end;    /// <summary>    /// Initializes g/l entry from gen. journal line.    /// </summary>    /// <remarks>    /// If g/l account used for posting has restricted dimensions, error is raised.    /// If g/l account selected for the gen. journal line is blocked or have different posting type.    /// </remarks>    /// <param name="GenJnlLine">general journal line that is being posted.</param>    /// <param name="GLEntry">Return value: g/l entry that is being created.</param>    /// <param name="GLAccNo">G/l account that will be used to create e/l entry.</param>    /// <param name="Amount">Amount that will be used for g/l entry (in local currency).</param>    /// <param name="AmountAddCurr">Amount that will be used for g/l entry (in additional currency).</param>    /// <param name="UseAmountAddCurr">Determines if amount in the field "Additional-Currency Amount" should be used for the new g/l entry or should it be caculated.</param>    /// <param name="SystemCreatedEntry">Determines if g/l entry is created by the system.</param>    procedure InitGLEntry(GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; GLAccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; UseAmountAddCurr: Boolean; SystemCreatedEntry: Boolean)    begin        InitGLEntry(GenJnlLine, GLEntry, GLAccNo, Amount, AmountAddCurr, UseAmountAddCurr, SystemCreatedEntry, 0);    end;    procedure InitGLEntry(GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; GLAccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; UseAmountAddCurr: Boolean; SystemCreatedEntry: Boolean; AmountSrcCurr: Decimal)    var        GLAcc: Record "G/L Account";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInitGLEntry(GenJnlLine, GLAccNo, SystemCreatedEntry, Amount, AmountAddCurr, FADimAlreadyChecked, IsHandled, GLEntry, UseAmountAddCurr, NextEntryNo, NextTransactionNo);        if not IsHandled then begin            if GLAccNo <> '' then begin                GLAcc.Get(GLAccNo);                IsHandled := false;                OnInitGLEntryOnBeforeCheckGLAccountBlocked(GenJnlLine, GLAcc, IsHandled);                if not IsHandled then                    GLAcc.TestField(Blocked, false);                GLAcc.TestField("Account Type", GLAcc."Account Type"::Posting);                // Check the Value Posting field on the G/L Account if it is not checked already in Codeunit 11                if (not                    ((GLAccNo = GenJnlLine."Account No.") and                    (GenJnlLine."Account Type" = GenJnlLine."Account Type"::"G/L Account")) or                    ((GLAccNo = GenJnlLine."Bal. Account No.") and                    (GenJnlLine."Bal. Account Type" = GenJnlLine."Bal. Account Type"::"G/L Account"))) and                not FADimAlreadyChecked                then begin                    OnInitGLEntryOnBeforeCheckGLAccDimError(GenJnlLine, GLAcc);                    CheckGLAccDimError(GenJnlLine, GLAccNo);                end;            end;            GLEntry.Init();            GLEntry.CopyFromGenJnlLine(GenJnlLine);            GLEntry."Entry No." := NextEntryNo;            GLEntry."Transaction No." := NextTransactionNo;            GLEntry."G/L Account No." := GLAccNo;            GLEntry."System-Created Entry" := SystemCreatedEntry;            GLEntry.Amount := Amount;            GLEntry."Additional-Currency Amount" :=                GLCalcAddCurrency(Amount, AmountAddCurr, GLEntry."Additional-Currency Amount", UseAmountAddCurr, GenJnlLine);            if GLEntry."G/L Account No." <> '' then begin                GLAcc.Get(GLEntry."G/L Account No.");                GenJnlCheckLine.CheckGLAccountSourceCurrency(GLAcc, GenJnlLine."Source Currency Code");            end;            GLEntry."Source Currency Code" := GenJnlLine."Source Currency Code";            if not GenJnlLine."Zero Src. Curr. Amount" then                GLEntry."Source Currency Amount" := AmountSrcCurr;        end;        OnAfterInitGLEntry(GLEntry, GenJnlLine, Amount, AmountAddCurr, UseAmountAddCurr, CurrencyFactor, GLReg);    end;    /// <summary>    /// Initializes g/l entry from gen. journal line and summarizes VAT g/l entries.    /// </summary>    /// <param name="GenJnlLine">General journal line that is being posted.</param>    /// <param name="AccNo">G/l account that will be used for new g/l entry.</param>    /// <param name="BalAccNo">Account that will be used for new g/l entry as the balancing account.</param>    /// <param name="Amount">Amount that will be used for g/l entry (in local currency).</param>    /// <param name="AmountAddCurr">Amount that will be used for g/l entry (in additional currency).</param>    /// <param name="UseAmtAddCurr">Determines if amount in the field "Additional-Currency Amount" should be used for the new g/l entry or should it be caculated.</param>    procedure InitGLEntryVAT(GenJnlLine: Record "Gen. Journal Line"; AccNo: Code[20]; BalAccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; UseAmtAddCurr: Boolean)    var        GLEntry: Record "G/L Entry";    begin        OnBeforeInitGLEntryVAT(GenJnlLine, GLEntry);        if UseAmtAddCurr then            InitGLEntry(                GenJnlLine, GLEntry, AccNo, Amount, AmountAddCurr, true, true,                CalcAmountSrcCurr(GenJnlLine, Amount))        else begin            InitGLEntry(                GenJnlLine, GLEntry, AccNo, Amount, 0, false, true,                CalcAmountSrcCurr(GenJnlLine, Amount));            GLEntry."Additional-Currency Amount" := AmountAddCurr;            GLEntry."Bal. Account No." := BalAccNo;        end;        OnInitGLEntryVATOnBeforeSummarizeVAT(GenJnlLine, GLEntry, VATEntry);        SummarizeVATFromInitGLEntryVAT(GLEntry, Amount);        OnAfterInitGLEntryVAT(GenJnlLine, GLEntry);    end;    local procedure SummarizeVATFromInitGLEntryVAT(var GLEntry: Record "G/L Entry"; Amount: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSummarizeVATFromInitGLEntryVAT(GLEntry, Amount, IsHandled);        if IsHandled then            exit;        SummarizeVAT(GLSetup."Summarize G/L Entries", GLEntry);    end;    /// <summary>    /// Initializes a general ledger entry for VAT posting with data copied from an existing VAT entry.    /// Creates G/L entry with dimension and posting details derived from the source VAT entry.    /// </summary>    /// <param name="GenJnlLine">General journal line that is being posted</param>    /// <param name="AccNo">G/L account number for the new entry</param>    /// <param name="BalAccNo">Balancing account number for the new entry</param>    /// <param name="Amount">Amount for the G/L entry in local currency</param>    /// <param name="AmountAddCurr">Amount for the G/L entry in additional currency</param>    /// <param name="VATEntry">Source VAT entry to copy posting details from</param>    /// <returns>Entry number of the created G/L entry</returns>    procedure InitGLEntryVATCopy(GenJnlLine: Record "Gen. Journal Line"; AccNo: Code[20]; BalAccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; VATEntry: Record "VAT Entry"): Integer    var        GLEntry: Record "G/L Entry";    begin        OnBeforeInitGLEntryVATCopy(GenJnlLine, GLEntry, VATEntry, NextEntryNo);        InitGLEntry(            GenJnlLine, GLEntry, AccNo, Amount, 0, false, true,            CalcAmountSrcCurr(GenJnlLine, Amount));        GLEntry."Additional-Currency Amount" := AmountAddCurr;        GLEntry."Bal. Account No." := BalAccNo;        GLEntry.CopyPostingGroupsFromVATEntry(VATEntry);        OnInitGLEntryVATCopyOnBeforeSummarizeVAT(GenJnlLine, GLEntry, VATEntry);        SummarizeVAT(GLSetup."Summarize G/L Entries", GLEntry);        OnAfterInitGLEntryVATCopy(GenJnlLine, GLEntry);        exit(GLEntry."Entry No.");    end;    /// <summary>    /// Updates the amounts of the g/l entry and adds it to the TempGLEntryBuffer to be inserted.    /// </summary>    /// <remarks>    /// If g/l entry amount is not properly rounded, error is raised.    /// </remarks>    /// <param name="GenJnlLine">General journal line that is being posted.</param>    /// <param name="GLEntry">G/l entry that needs to be inserted.</param>    /// <param name="CalcAddCurrResiduals">Determined if residual rounding amount should be posted as a separate g/l entry.</param>    procedure InsertGLEntry(GenJnlLine: Record "Gen. Journal Line"; GLEntry: Record "G/L Entry"; CalcAddCurrResiduals: Boolean)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertGlEntry(GenJnlLine, GLEntry, IsHandled);        if not IsHandled then begin            GLEntry.TestField("G/L Account No.");            IsHandled := false;            OnInsertGLEntryOnBeforeCheckAmountRounding(GLEntry, IsHandled, GenJnlLine);            if not IsHandled then                if GLEntry.Amount <> Round(GLEntry.Amount) then                    GLEntry.FieldError(GLEntry.Amount, StrSubstNo(NeedsRoundingErr, GLEntry.Amount));            OnInsertGLEntryOnBeforeUpdateCheckAmounts(GLSetup, GLEntry, BalanceCheckAmount, BalanceCheckAmount2, BalanceCheckAddCurrAmount, BalanceCheckAddCurrAmount2);            UpdateCheckAmounts(              GLEntry."Posting Date", GLEntry.Amount, GLEntry."Additional-Currency Amount", GLEntry."Source Currency Amount",              BalanceCheckAmount, BalanceCheckAmount2, BalanceCheckAddCurrAmount, BalanceCheckAddCurrAmount2, BalanceCheckSrcCurrAmount, BalanceCheckSrcCurrAmount2);            GLEntry.UpdateDebitCredit(GenJnlLine.Correction);            OnInsertGLEntryOnBeforeAssignTempGLEntryBuf(GLEntry, GenJnlLine, GLReg);            TempGLEntryBuf := GLEntry;            OnBeforeInsertGLEntryBuffer(                TempGLEntryBuf, GenJnlLine, BalanceCheckAmount, BalanceCheckAmount2, BalanceCheckAddCurrAmount, BalanceCheckAddCurrAmount2,                NextEntryNo, TotalAmount, TotalAddCurrAmount, GLEntry);            TempGLEntryBuf.Insert();            if FirstEntryNo = 0 then                FirstEntryNo := TempGLEntryBuf."Entry No.";            IncrNextEntryNo();            if CalcAddCurrResiduals then                HandleAddCurrResidualGLEntry(GenJnlLine, GLEntry);        end;        OnAfterInsertGLEntry(GLEntry, GenJnlLine, TempGLEntryBuf, CalcAddCurrResiduals);    end;    /// <summary>    /// Initializes the g/l entry from the general journal line and adds it to the TempGLEntryBuffer to be inserted.    /// </summary>    /// <param name="GenJnlLine">General journal line that is being posted.</param>    /// <param name="AccNo">G/l account that will be used for new g/l entry.</param>    /// <param name="Amount">Amount that will be used for g/l entry (in local currency).</param>    /// <param name="AmountAddCurr">Amount that will be used for g/l entry (in additional currency).</param>    /// <param name="UseAmtAddCurr">Determines if amount in the field "Additional-Currency Amount" should be used for the new g/l entry or should it be caculated.</param>    procedure CreateGLEntry(GenJnlLine: Record "Gen. Journal Line"; AccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; UseAmountAddCurr: Boolean)    begin        CreateGLEntry(GenJnlLine, AccNo, Amount, AmountAddCurr, UseAmountAddCurr, 0);    end;    procedure CreateGLEntry(GenJnlLine: Record "Gen. Journal Line"; AccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; UseAmountAddCurr: Boolean; AmountSrcCurr: Decimal)    var        GLEntry: Record "G/L Entry";    begin        if (AddCurrencyCode <> '') and MultiplePostingGroups then            UseAmountAddCurr := true;        if UseAmountAddCurr then            InitGLEntry(GenJnlLine, GLEntry, AccNo, Amount, AmountAddCurr, true, true, AmountSrcCurr)        else begin            InitGLEntry(GenJnlLine, GLEntry, AccNo, Amount, 0, false, true, AmountSrcCurr);            GLEntry."Additional-Currency Amount" := AmountAddCurr;        end;        OnCreateGLEntryOnBeforeInsertGLEntry(GenJnlLine, GLEntry, VATEntry);        InsertGLEntry(GenJnlLine, GLEntry, true);        OnAfterCreateGLEntry(GenJnlLine, GLEntry, NextEntryNo);    end;    /// <summary>    /// Initializes the g/l entry from the general journal line. Fills balance account information and adds it to the TempGLEntryBuffer to be inserted.    /// </summary>    /// <param name="GenJnlLine">General journal line that is being posted.</param>    /// <param name="AccNo">G/l account that will be used for new g/l entry.</param>    /// <param name="Amount">Amount that will be used for g/l entry (in local currency).</param>    /// <param name="AmountAddCurr">Amount that will be used for g/l entry (in additional currency).</param>    /// <param name="BalAccType">Balance account type to be used for the g/l entry.</param>    /// <param name="BalAccNo">Balance account no. to be used for the g/l entry.</param>    procedure CreateGLEntryBalAcc(GenJnlLine: Record "Gen. Journal Line"; AccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; BalAccType: Enum "Gen. Journal Account Type"; BalAccNo: Code[20])    var        GLEntry: Record "G/L Entry";        AmountSrcCurr: Decimal;    begin        OnBeforeCreateGLEntryBalAcc(GenJnlLine, AccNo, Amount, AmountAddCurr, BalAccType, BalAccNo);        AmountAddCurr := AmountAddCurr - GenJnlLine."VAT Amount";        if GenJnlLine."Source Currency Code" <> '' then            AmountSrcCurr := AmountAddCurr        else            AmountSrcCurr := CalcAmountSrcCurr(GenJnlLine, Amount);        InitGLEntry(            GenJnlLine, GLEntry, AccNo, Amount, AmountAddCurr, true, true,            AmountSrcCurr);        GLEntry."Bal. Account Type" := BalAccType;        GLEntry."Bal. Account No." := BalAccNo;        InsertGLEntry(GenJnlLine, GLEntry, true);        OnMoveGenJournalLine(GenJnlLine, GLEntry.RecordId);        OnAfterCreateGLEntryBalAcc(GenJnlLine, GLEntry);    end;    local procedure CreateGLEntryGainLoss(GenJnlLine: Record "Gen. Journal Line"; AccNo: Code[20]; Amount: Decimal; UseAmountAddCurr: Boolean)    var        GLEntry: Record "G/L Entry";    begin        SetPostingDimensions(GenJnlLine, AccNo);        InitGLEntry(GenJnlLine, GLEntry, AccNo, Amount, 0, UseAmountAddCurr, true, 0);        OnBeforeCreateGLEntryGainLossInsertGLEntry(GenJnlLine, GLEntry);        InsertGLEntry(GenJnlLine, GLEntry, true);    end;    /// <summary>    /// Initializes the g/l entry from the general journal line and detailed cv. ledger entry buffer, adds the g/l entry to the TempGLEntryBuffer to be inserted.    /// Inserts vat entries.    /// </summary>    /// <param name="GenJnlLine">General journal line that is being posted.</param>    /// <param name="AccNo">G/l account that will be used for new g/l entry.</param>    /// <param name="Amount">Amount that will be used for g/l entry (in local currency).</param>    /// <param name="AmountAddCurr">Amount that will be used for g/l entry (in additional currency).</param>    /// <param name="VATAmount">Vat amount that will be used for g/l entry.</param>    /// <param name="DtldCVLedgEntryBuf">DtldCVLedgerEntry Buffer that holds the information about posting groups and tax information that will be used for g/l entry creation.</param>    procedure CreateGLEntryVAT(GenJnlLine: Record "Gen. Journal Line"; AccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; VATAmount: Decimal; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    var        GLEntry: Record "G/L Entry";    begin        OnBeforeCreateGLEntryVAT(GenJnlLine, DtldCVLedgEntryBuf);        InitGLEntry(            GenJnlLine, GLEntry, AccNo, Amount, 0, false, true,            CalcAmountSrcCurr(GenJnlLine, Amount));        GLEntry."Additional-Currency Amount" := AmountAddCurr;        GLEntry."VAT Amount" := VATAmount;        GLEntry.CopyPostingGroupsFromDtldCVBuf(DtldCVLedgEntryBuf, DtldCVLedgEntryBuf."Gen. Posting Type".AsInteger());        OnCreateGLEntryVATOnBeforeInsertGLEntry(GenJnlLine, GLEntry);        InsertGLEntry(GenJnlLine, GLEntry, true);        InsertVATEntriesFromTemp(DtldCVLedgEntryBuf, GLEntry);    end;    /// <summary>    /// Initializes the g/l entry from the general journal line and detailed cv. ledger entry buffer, adds the g/l entry to the TempGLEntryBuffer to be inserted.    /// Collects needed adjustments, inserts vat entries.    /// </summary>    /// <param name="GenJnlLine">General journal line that is being posted.</param>    /// <param name="AccNo">G/l account that will be used for new g/l entry.</param>    /// <param name="Amount">Amount that will be used for g/l entry (in local currency).</param>    /// <param name="AmountAddCurr">Amount that will be used for g/l entry (in additional currency).</param>    /// <param name="VATAmount">Vat amount that will be used for g/l entry.</param>    /// <param name="DtldCVLedgEntryBuf">DtldCVLedgerEntry Buffer that holds the information about posting groups and tax information that will be used for g/l entry creation.</param>    /// <param name="AdjAmount">Return value: the adjustment amount for the g/l entry.</param>    procedure CreateGLEntryVATCollectAdj(GenJnlLine: Record "Gen. Journal Line"; AccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; VATAmount: Decimal; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var AdjAmount: array[4] of Decimal)    var        GLEntry: Record "G/L Entry";    begin        OnBeforeCreateGLEntryVATCollectAdj(GenJnlLine, DtldCVLedgEntryBuf);        InitGLEntry(            GenJnlLine, GLEntry, AccNo, Amount, 0, false, true,            CalcAmountSrcCurr(GenJnlLine, Amount));        GLEntry."Additional-Currency Amount" := AmountAddCurr;        GLEntry."VAT Amount" := VATAmount;        GlEntry."Non-Deductible VAT Amount" := -DtldCVLedgEntryBuf."Non-Deductible VAT Amount LCY";        GlEntry."Non-Deductible VAT Amount ACY" := -DtldCVLedgEntryBuf."Non-Deductible VAT Amount ACY";        GLEntry.CopyPostingGroupsFromDtldCVBuf(DtldCVLedgEntryBuf, DtldCVLedgEntryBuf."Gen. Posting Type".AsInteger());        InsertGLEntry(GenJnlLine, GLEntry, true);        CollectAdjustment(AdjAmount, GLEntry.Amount, GLEntry."Additional-Currency Amount");        InsertVATEntriesFromTemp(DtldCVLedgEntryBuf, GLEntry);    end;    local procedure CreateGLEntryFromVATEntry(GenJnlLine: Record "Gen. Journal Line"; VATAccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; VATEntry: Record "VAT Entry"): Integer    var        GLEntry: Record "G/L Entry";    begin        InitGLEntry(            GenJnlLine, GLEntry, VATAccNo, Amount, 0, false, true,            CalcAmountSrcCurr(GenJnlLine, Amount));        GLEntry."Additional-Currency Amount" := AmountAddCurr;        GLEntry.CopyPostingGroupsFromVATEntry(VATEntry);        OnBeforeInsertGLEntryFromVATEntry(GLEntry, VATEntry);        InsertGLEntry(GenJnlLine, GLEntry, true);        exit(GLEntry."Entry No.");    end;    local procedure CreateDeferralScheduleFromGL(var GenJournalLine: Record "Gen. Journal Line"; IsBalancing: Boolean)    begin        if (GenJournalLine."Account No." <> '') and (GenJournalLine."Deferral Code" <> '') then            if ((GenJournalLine."Account Type" in [GenJournalLine."Account Type"::Customer, GenJournalLine."Account Type"::Vendor])                and (JournalsSourceCodesList.Contains(GenJournalLine."Source Code"))) or               (GenJournalLine."Account Type" in [GenJournalLine."Account Type"::"G/L Account", GenJournalLine."Account Type"::"Bank Account"])            then begin                if not IsBalancing then                    CODEUNIT.Run(CODEUNIT::"Exchange Acc. G/L Journal Line", GenJournalLine);                DeferralUtilities.CreateScheduleFromGL(GenJournalLine, FirstEntryNo);            end;    end;    local procedure UpdateCheckAmounts(PostingDate: Date; Amount: Decimal; AddCurrAmount: Decimal; SrcCurrAmount: Decimal; var BalanceCheckAmount: Decimal; var BalanceCheckAmount2: Decimal; var BalanceCheckAddCurrAmount: Decimal; var BalanceCheckAddCurrAmount2: Decimal; var BalanceCheckSrcCurrAmount: Decimal; var BalanceCheckSrcCurrAmount2: Decimal)    begin        if PostingDate = NormalDate(PostingDate) then begin            BalanceCheckAmount :=              BalanceCheckAmount + Amount * ((PostingDate - 00000101D) mod 99 + 1);            BalanceCheckAmount2 :=              BalanceCheckAmount2 + Amount * ((PostingDate - 00000101D) mod 98 + 1);        end else begin            BalanceCheckAmount :=              BalanceCheckAmount + Amount * ((NormalDate(PostingDate) - 00000101D + 50) mod 99 + 1);            BalanceCheckAmount2 :=              BalanceCheckAmount2 + Amount * ((NormalDate(PostingDate) - 00000101D + 50) mod 98 + 1);        end;        if AddCurrencyCode <> '' then            if PostingDate = NormalDate(PostingDate) then begin                BalanceCheckAddCurrAmount :=                  BalanceCheckAddCurrAmount + AddCurrAmount * ((PostingDate - 00000101D) mod 99 + 1);                BalanceCheckAddCurrAmount2 :=                  BalanceCheckAddCurrAmount2 + AddCurrAmount * ((PostingDate - 00000101D) mod 98 + 1);            end else begin                BalanceCheckAddCurrAmount :=                  BalanceCheckAddCurrAmount +                  AddCurrAmount * ((NormalDate(PostingDate) - 00000101D + 50) mod 99 + 1);                BalanceCheckAddCurrAmount2 :=                  BalanceCheckAddCurrAmount2 +                  AddCurrAmount * ((NormalDate(PostingDate) - 00000101D + 50) mod 98 + 1);            end        else begin            BalanceCheckAddCurrAmount := 0;            BalanceCheckAddCurrAmount2 := 0;        end;        GetGLSetup();        if GLSetup."Check Source Curr. Consistency" then            if PostingDate = NormalDate(PostingDate) then begin                BalanceCheckSrcCurrAmount += SrcCurrAmount * ((PostingDate - 00000101D) mod 99 + 1);                BalanceCheckSrcCurrAmount2 += SrcCurrAmount * ((PostingDate - 00000101D) mod 98 + 1);            end else begin                BalanceCheckSrcCurrAmount += SrcCurrAmount * ((NormalDate(PostingDate) - 00000101D + 50) mod 99 + 1);                BalanceCheckSrcCurrAmount2 += SrcCurrAmount * ((NormalDate(PostingDate) - 00000101D + 50) mod 98 + 1);            end        else begin            BalanceCheckSrcCurrAmount := 0;            BalanceCheckSrcCurrAmount2 := 0;        end;    end;    local procedure CalcPmtDiscPossible(GenJnlLine: Record "Gen. Journal Line"; var CVLedgEntryBuf: Record "CV Ledger Entry Buffer")    var        PaymentDiscountDateWithGracePeriod: Date;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcPmtDiscPossible(GenJnlLine, CVLedgEntryBuf, IsHandled, AmountRoundingPrecision);        if IsHandled then            exit;        if GenJnlLine."Amount (LCY)" <> 0 then begin            PaymentDiscountDateWithGracePeriod := CVLedgEntryBuf."Pmt. Discount Date";            GLSetup.GetRecordOnce();            if PaymentDiscountDateWithGracePeriod <> 0D then                PaymentDiscountDateWithGracePeriod :=                  CalcDate(GLSetup."Payment Discount Grace Period", PaymentDiscountDateWithGracePeriod);            if (PaymentDiscountDateWithGracePeriod >= CVLedgEntryBuf."Posting Date") or               (PaymentDiscountDateWithGracePeriod = 0D)            then begin                if GLSetup."Pmt. Disc. Excl. VAT" then begin                    if GenJnlLine."Sales/Purch. (LCY)" = 0 then                        CVLedgEntryBuf."Original Pmt. Disc. Possible" := (GenJnlLine."Amount (LCY)" + TotalVATAmountOnJnlLines(GenJnlLine)) * GenJnlLine.Amount / GenJnlLine."Amount (LCY)"                    else                        CVLedgEntryBuf."Original Pmt. Disc. Possible" := GenJnlLine."Sales/Purch. (LCY)" * GenJnlLine.Amount / GenJnlLine."Amount (LCY)"                end else                    CVLedgEntryBuf."Original Pmt. Disc. Possible" := GenJnlLine.Amount;                OnCalcPmtDiscPossibleOnBeforeOriginalPmtDiscPossible(GenJnlLine, CVLedgEntryBuf, AmountRoundingPrecision);                CVLedgEntryBuf."Original Pmt. Disc. Possible" :=                    Round(CVLedgEntryBuf."Original Pmt. Disc. Possible" * GenJnlLine."Payment Discount %" / 100, AmountRoundingPrecision);            end;            CVLedgEntryBuf."Remaining Pmt. Disc. Possible" := CVLedgEntryBuf."Original Pmt. Disc. Possible";        end;        OnAfterCalcPmtDiscPossible(GenJnlLine, CVLedgEntryBuf);    end;    local procedure CalcPmtTolerancePossible(GenJnlLine: Record "Gen. Journal Line"; PmtDiscountDate: Date; var PmtDiscToleranceDate: Date; var MaxPaymentTolerance: Decimal)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcPmtTolerancePossible(GenJnlLine, PmtDiscountDate, PmtDiscToleranceDate, MaxPaymentTolerance, IsHandled);        if IsHandled then            exit;        if GenJnlLine."Document Type" in [GenJnlLine."Document Type"::Invoice, GenJnlLine."Document Type"::"Credit Memo"] then begin            if PmtDiscountDate <> 0D then                PmtDiscToleranceDate := CalcDate(GLSetup."Payment Discount Grace Period", PmtDiscountDate)            else                PmtDiscToleranceDate := PmtDiscountDate;            case GenJnlLine."Account Type" of                GenJnlLine."Account Type"::Customer:                    PaymentToleranceMgt.CalcMaxPmtTolerance(GenJnlLine."Document Type", GenJnlLine."Currency Code", GenJnlLine.Amount, GenJnlLine."Amount (LCY)", 1, MaxPaymentTolerance);                GenJnlLine."Account Type"::Vendor:                    PaymentToleranceMgt.CalcMaxPmtTolerance(GenJnlLine."Document Type", GenJnlLine."Currency Code", GenJnlLine.Amount, GenJnlLine."Amount (LCY)", -1, MaxPaymentTolerance);            end;        end;    end;    local procedure CalcPmtTolerance(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; var PmtTolAmtToBeApplied: Decimal; NextTransactionNo: Integer; FirstNewVATEntryNo: Integer)    var        PmtTol: Decimal;        PmtTolLCY: Decimal;        PmtTolAddCurr: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcPmtTolerance(          NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine, PmtTolAmtToBeApplied, IsHandled);        if IsHandled then            exit;        if OldCVLedgEntryBuf2."Accepted Payment Tolerance" = 0 then            exit;        PmtTol := -OldCVLedgEntryBuf2."Accepted Payment Tolerance";        PmtTolAmtToBeApplied := PmtTolAmtToBeApplied + PmtTol;        PmtTolLCY :=            Round((NewCVLedgEntryBuf."Original Amount" + PmtTol) / NewCVLedgEntryBuf."Original Currency Factor") -            NewCVLedgEntryBuf."Original Amt. (LCY)";        OnCalcPmtToleranceOnAfterAssignPmtDisc(            PmtTol, PmtTolLCY, PmtTolAmtToBeApplied, OldCVLedgEntryBuf, OldCVLedgEntryBuf2,            NewCVLedgEntryBuf, DtldCVLedgEntryBuf, NextTransactionNo, FirstNewVATEntryNo);        OldCVLedgEntryBuf."Accepted Payment Tolerance" := 0;        OldCVLedgEntryBuf."Pmt. Tolerance (LCY)" := -PmtTolLCY;        if NewCVLedgEntryBuf."Currency Code" = AddCurrencyCode then            PmtTolAddCurr := PmtTol        else            PmtTolAddCurr := CalcLCYToAddCurr(PmtTolLCY);        if not GLSetup."Pmt. Disc. Excl. VAT" and GLSetup."Adjust for Payment Disc." and (PmtTolLCY <> 0) then            CalcPmtDiscIfAdjVAT(                NewCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine, PmtTolLCY, PmtTolAddCurr,                NextTransactionNo, FirstNewVATEntryNo, DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Excl.)");        OnBeforeInitDetailedCVLedgEntryBufCalcPmtTolerance(            NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2,            DtldCVLedgEntryBuf, GenJnlLine, PmtTolAmtToBeApplied, NextTransactionNo, FirstNewVATEntryNo, PmtTol, PmtTolLCY, PmtTolAddCurr);        DtldCVLedgEntryBuf.InitDetailedCVLedgEntryBuf(            GenJnlLine, NewCVLedgEntryBuf, DtldCVLedgEntryBuf,            DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance", PmtTol, PmtTolLCY, PmtTolAddCurr, 0, 0, 0);        OnAfterCalcPmtTolerance(DtldCVLedgEntryBuf, OldCVLedgEntryBuf2, PmtTol, PmtTolLCY, GenJnlLine);    end;    local procedure CalcPmtDisc(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; PmtTolAmtToBeApplied: Decimal; ApplnRoundingPrecision: Decimal; NextTransactionNo: Integer; FirstNewVATEntryNo: Integer)    var        PmtDisc: Decimal;        PmtDiscLCY: Decimal;        PmtDiscAddCurr: Decimal;        MinimalPossibleLiability: Decimal;        PaymentExceedsLiability: Boolean;        ToleratedPaymentExceedsLiability: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcPmtDisc(            NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine, PmtTolAmtToBeApplied, IsHandled,            ApplnRoundingPrecision, NextTransactionNo, FirstNewVATEntryNo, AddCurrencyCode);        if IsHandled then            exit;        MinimalPossibleLiability := Abs(OldCVLedgEntryBuf2."Remaining Amount" - OldCVLedgEntryBuf2.GetRemainingPmtDiscPossible(NewCVLedgEntryBuf."Posting Date"));        OnAfterCalcMinimalPossibleLiability(NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, MinimalPossibleLiability);        PaymentExceedsLiability := Abs(OldCVLedgEntryBuf2."Amount to Apply") >= MinimalPossibleLiability;        OnAfterCalcPaymentExceedsLiability(            NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, MinimalPossibleLiability, PaymentExceedsLiability);        ToleratedPaymentExceedsLiability :=            Abs(NewCVLedgEntryBuf."Remaining Amount" + PmtTolAmtToBeApplied) >= MinimalPossibleLiability;        OnAfterCalcToleratedPaymentExceedsLiability(            NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, MinimalPossibleLiability,            ToleratedPaymentExceedsLiability, PmtTolAmtToBeApplied);        if (PaymentToleranceMgt.CheckCalcPmtDisc(NewCVLedgEntryBuf, OldCVLedgEntryBuf2, ApplnRoundingPrecision, true, true) and            ((OldCVLedgEntryBuf2."Amount to Apply" = 0) or PaymentExceedsLiability) or            (PaymentToleranceMgt.CheckCalcPmtDisc(NewCVLedgEntryBuf, OldCVLedgEntryBuf2, ApplnRoundingPrecision, false, false) and             (OldCVLedgEntryBuf2."Amount to Apply" <> 0) and PaymentExceedsLiability and ToleratedPaymentExceedsLiability))        then begin            PmtDisc := -OldCVLedgEntryBuf2.GetRemainingPmtDiscPossible(NewCVLedgEntryBuf."Posting Date");            PmtDiscLCY :=              Round(                (NewCVLedgEntryBuf."Original Amount" + PmtDisc) / NewCVLedgEntryBuf."Original Currency Factor") -              NewCVLedgEntryBuf."Original Amt. (LCY)";            OnCalcPmtDiscOnAfterAssignPmtDisc(PmtDisc, PmtDiscLCY, OldCVLedgEntryBuf, OldCVLedgEntryBuf2);            OldCVLedgEntryBuf."Pmt. Disc. Given (LCY)" := -PmtDiscLCY;            if (NewCVLedgEntryBuf."Currency Code" = AddCurrencyCode) and (AddCurrencyCode <> '') then                PmtDiscAddCurr := PmtDisc            else                PmtDiscAddCurr := CalcLCYToAddCurr(PmtDiscLCY);            OnAfterCalcPmtDiscount(                NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine,                PmtTolAmtToBeApplied, PmtDisc, PmtDiscLCY, PmtDiscAddCurr);            if not GLSetup."Pmt. Disc. Excl. VAT" and GLSetup."Adjust for Payment Disc." and (PmtDiscLCY <> 0) then                CalcPmtDiscIfAdjVAT(                  NewCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine, PmtDiscLCY, PmtDiscAddCurr,                  NextTransactionNo, FirstNewVATEntryNo, DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Excl.)");            OnCalcPmtDiscBeforeInitDetailedCVLedgEntryBuff(GenJnlLine, IsHandled);            if not IsHandled then                DtldCVLedgEntryBuf.InitDetailedCVLedgEntryBuf(                    GenJnlLine, NewCVLedgEntryBuf, DtldCVLedgEntryBuf,                    DtldCVLedgEntryBuf."Entry Type"::"Payment Discount", PmtDisc, PmtDiscLCY, PmtDiscAddCurr, 0, 0, 0);            OnCalcPmtDiscOnAfterCalcPmtDisc(DtldCVLedgEntryBuf, OldCVLedgEntryBuf2, PmtDisc, PmtDiscLCY, GenJnlLine);        end;    end;    local procedure CalcPmtDiscIfAdjVAT(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; var PmtDiscLCY2: Decimal; var PmtDiscAddCurr2: Decimal; NextTransactionNo: Integer; FirstNewVATEntryNo: Integer; EntryType: Enum "Detailed CV Ledger Entry Type")    var        VATEntry2: Record "VAT Entry";        VATPostingSetup: Record "VAT Posting Setup";        TaxJurisdiction: Record "Tax Jurisdiction";        DtldCVLedgEntryBuf2: Record "Detailed CV Ledg. Entry Buffer";        OriginalAmountAddCurr: Decimal;        PmtDiscRounding: Decimal;        PmtDiscRoundingAddCurr: Decimal;        PmtDiscFactorLCY: Decimal;        PmtDiscFactorAddCurr: Decimal;        VATBase: Decimal;        VATBaseAddCurr: Decimal;        VATAmount: Decimal;        VATAmountAddCurr: Decimal;        TotalVATAmount: Decimal;        NonDedVATBase: Decimal;        NonDedVATBaseAddCurr: Decimal;        NonDedVATAmount: Decimal;        NonDedVATAmountAddCurr: Decimal;        NonDedTotalVATAmount: Decimal;        NonDedTotalVATAmountACY: Decimal;        NonDedReverseChargeVATBasePmtDisc: Decimal;        NonDedReverseChargeVATBasePmtDiscACY: Decimal;        LastConnectionNo: Integer;        VATEntryModifier: Integer;    begin        if OldCVLedgEntryBuf."Original Amt. (LCY)" = 0 then            exit;        if (AddCurrencyCode = '') or (AddCurrencyCode = OldCVLedgEntryBuf."Currency Code") then            OriginalAmountAddCurr := OldCVLedgEntryBuf.Amount        else            OriginalAmountAddCurr := CalcLCYToAddCurr(OldCVLedgEntryBuf."Original Amt. (LCY)");        PmtDiscRounding := PmtDiscLCY2;        PmtDiscFactorLCY := PmtDiscLCY2 / OldCVLedgEntryBuf."Original Amt. (LCY)";        if OriginalAmountAddCurr <> 0 then            PmtDiscFactorAddCurr := PmtDiscAddCurr2 / OriginalAmountAddCurr        else            PmtDiscFactorAddCurr := 0;        NonDedTotalVATAmount := 0;        NonDedTotalVATAmountACY := 0;        VATEntry2.ReadIsolation := IsolationLevel::ReadUncommitted;        VATEntry2.Reset();        VATEntry2.SetCurrentKey("Transaction No.");        VATEntry2.SetRange("Transaction No.", OldCVLedgEntryBuf."Transaction No.");        if OldCVLedgEntryBuf."Transaction No." = NextTransactionNo then            VATEntry2.SetRange("Entry No.", 0, FirstNewVATEntryNo - 1);        OnCalcPmtDiscIfAdjVATOnBeforeVATEntryFind(            GenJnlLine, OldCVLedgEntryBuf, NewCVLedgEntryBuf, VATEntry2,            PmtDiscLCY2, PmtDiscAddCurr2, PmtDiscFactorLCY, PmtDiscFactorAddCurr);        if VATEntry2.FindSet() then begin            TotalVATAmount := 0;            LastConnectionNo := 0;            repeat                OnCalcPmtDiscAdjVATAmountsOnBeforeProcessVATEntry(GenJnlLine, OldCVLedgEntryBuf, NewCVLedgEntryBuf, VATEntry2);                VATPostingSetup.Get(VATEntry2."VAT Bus. Posting Group", VATEntry2."VAT Prod. Posting Group");                if VATEntry2."VAT Calculation Type" =                   VATEntry2."VAT Calculation Type"::"Sales Tax"                then begin                    TaxJurisdiction.Get(VATEntry2."Tax Jurisdiction Code");                    VATPostingSetup."Adjust for Payment Discount" :=                      TaxJurisdiction."Adjust for Payment Discount";                end;                if VATPostingSetup."Adjust for Payment Discount" then begin                    if LastConnectionNo <> VATEntry2."Sales Tax Connection No." then begin                        if LastConnectionNo <> 0 then begin                            DtldCVLedgEntryBuf := DtldCVLedgEntryBuf2;                            DtldCVLedgEntryBuf."VAT Amount (LCY)" := -TotalVATAmount;                            DtldCVLedgEntryBuf."Non-Deductible VAT Amount LCY" := -NonDedTotalVATAmount;                            DtldCVLedgEntryBuf."Non-Deductible VAT Amount ACY" := -NonDedTotalVATAmountACY;                            DtldCVLedgEntryBuf.InsertDtldCVLedgEntry(DtldCVLedgEntryBuf, NewCVLedgEntryBuf, false);                            OnCalcPmtDiscIfAdjVATOnBeforeInsertSummarizedVATAdjForPaymentDiscount(DtldCVLedgEntryBuf, OldCVLedgEntryBuf);                            InsertSummarizedVAT(GenJnlLine);                        end;                        CalcPmtDiscVATBases(VATEntry2, VATBase, VATBaseAddCurr, NonDedVATBase, NonDedVATBaseAddCurr);                        VATBase :=                            CalcAmtMultipliedByFactorWithRounding(                                PmtDiscRounding, PmtDiscLCY2, VATBase, PmtDiscFactorLCY);                        NonDedVATBase :=                            CalcAmtMultipliedByFactorWithRounding(                                PmtDiscRounding, PmtDiscLCY2, NonDedVATBase, PmtDiscFactorLCY);                        PmtDiscRoundingAddCurr := PmtDiscRoundingAddCurr + VATBaseAddCurr * PmtDiscFactorAddCurr;                        VATBaseAddCurr := Round(CalcLCYToAddCurr(VATBase), AddCurrency."Amount Rounding Precision");                        PmtDiscAddCurr2 := PmtDiscAddCurr2 + VATBaseAddCurr;                        PmtDiscRoundingAddCurr := PmtDiscRoundingAddCurr + NonDedVATBaseAddCurr * PmtDiscFactorAddCurr;                        NonDedVATBaseAddCurr := Round(CalcLCYToAddCurr(NonDedVATBase), AddCurrency."Amount Rounding Precision");                        PmtDiscAddCurr2 := PmtDiscAddCurr2 + NonDedVATBaseAddCurr;                        OnCalcPmtDiscIfAdjVATOnAfterCalcPmtDiscVATBases(VATEntry2, OldCVLedgEntryBuf, VATBase, VATBaseAddCurr, PmtDiscLCY2, PmtDiscAddCurr2);                        DtldCVLedgEntryBuf2.Init();                        DtldCVLedgEntryBuf2."Posting Date" := GenJnlLine."Posting Date";                        DtldCVLedgEntryBuf2."Document Type" := GenJnlLine."Document Type";                        DtldCVLedgEntryBuf2."Document No." := GenJnlLine."Document No.";                        DtldCVLedgEntryBuf2.Amount := 0;                        DtldCVLedgEntryBuf2."Amount (LCY)" := -VATBase;                        if VATEntry2."VAT Calculation Type" = VATEntry2."VAT Calculation Type"::"Normal VAT" then                            DtldCVLedgEntryBuf2."Amount (LCY)" -= NonDedVATBase;                        if VATEntry2."VAT Calculation Type" = VATEntry2."VAT Calculation Type"::"Reverse Charge VAT" then begin                            NonDedReverseChargeVATBasePmtDisc += NonDedVATBase;                            NonDedReverseChargeVATBasePmtDiscACY += NonDedVATBaseAddCurr;                        end;                        DtldCVLedgEntryBuf2."Entry Type" := EntryType;                        case EntryType of                            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Excl.)":                                VATEntryModifier := 1000000;                            DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Excl.)":                                VATEntryModifier := 2000000;                            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Excl.)":                                VATEntryModifier := 3000000;                        end;                        DtldCVLedgEntryBuf2.CopyFromCVLedgEntryBuf(NewCVLedgEntryBuf);                        // The total payment discount in currency is posted on the entry made in                        // the function CalcPmtDisc.                        DtldCVLedgEntryBuf2."User ID" := CopyStr(UserId(), 1, MaxStrLen(DtldCVLedgEntryBuf2."User ID"));                        DtldCVLedgEntryBuf2."Additional-Currency Amount" := -VATBaseAddCurr;                        OnCalcPmtDiscIfAdjVATCopyFields(DtldCVLedgEntryBuf2, OldCVLedgEntryBuf, GenJnlLine);                        DtldCVLedgEntryBuf2.CopyPostingGroupsFromVATEntry(VATEntry2);                        TotalVATAmount := 0;                        NonDedTotalVATAmount := 0;                        NonDedTotalVATAmountACY := 0;                        LastConnectionNo := VATEntry2."Sales Tax Connection No.";                    end;                    OnBeforeCalcPmtDiscVATAmounts(VATEntry2, DtldCVLedgEntryBuf2, GenJnlLine);                    CalcPmtDiscVATAmounts(                        VATEntry2, VATBase, VATBaseAddCurr, NonDedVATBase, NonDedVATBaseAddCurr,                        VATAmount, VATAmountAddCurr, NonDedVATAmount, NonDedVATAmountAddCurr,                        PmtDiscRounding, PmtDiscFactorLCY, PmtDiscLCY2, PmtDiscAddCurr2);                    if VATEntry2."VAT Calculation Type" = VATEntry2."VAT Calculation Type"::"Normal VAT" then                        DtldCVLedgEntryBuf2."Amount (LCY)" -= NonDedVATAmount;                    OnCalcPmtDiscIfAdjVATOnAfterCalcPmtDiscVATAmounts(                        VATEntry2, OldCVLedgEntryBuf, VATBase, VATBaseAddCurr, VATAmount, VATAmountAddCurr, PmtDiscLCY2, PmtDiscAddCurr2);                    TotalVATAmount := TotalVATAmount + VATAmount;                    NonDedTotalVATAmount := NonDedTotalVATAmount + NonDedVATAmount;                    NonDedTotalVATAmountACY := NonDedTotalVATAmountACY + NonDedVATAmountAddCurr;                    if (PmtDiscAddCurr2 <> 0) and (PmtDiscLCY2 = 0) then begin                        VATAmountAddCurr := VATAmountAddCurr - PmtDiscAddCurr2;                        PmtDiscAddCurr2 := 0;                    end;                    // Post VAT                    // VAT for VAT entry                    if VATEntry2.Type <> VATEntry2.Type::" " then                        InsertPmtDiscVATForVATEntry(                            GenJnlLine, TempVATEntry, VATEntry2, VATEntryModifier,                            VATAmount, VATAmountAddCurr, VATBase, VATBaseAddCurr,                            NonDedVATAmount, NonDedVATAmountAddCurr, NonDedVATBase, NonDedVATBaseAddCurr,                            PmtDiscFactorLCY, PmtDiscFactorAddCurr);                    OnCalcPmtDiscIfAdjVATOnBeforeInsertPmtDiscVATForGLEntry(VATEntry, VATEntry2, DtldCVLedgEntryBuf2);                    // VAT for G/L entry/entries                    InsertPmtDiscVATForGLEntry(                        GenJnlLine, DtldCVLedgEntryBuf, NewCVLedgEntryBuf, VATEntry2,                        VATPostingSetup, TaxJurisdiction, EntryType, VATAmount, VATAmountAddCurr, NonDedVATAmount, NonDedVATAmountAddCurr);                end;            until VATEntry2.Next() = 0;            if LastConnectionNo <> 0 then begin                DtldCVLedgEntryBuf := DtldCVLedgEntryBuf2;                DtldCVLedgEntryBuf."VAT Amount (LCY)" := -TotalVATAmount;                DtldCVLedgEntryBuf."Non-Deductible VAT Amount LCY" := -NonDedTotalVATAmount;                DtldCVLedgEntryBuf."Non-Deductible VAT Amount ACY" := -NonDedTotalVATAmountACY;                DtldCVLedgEntryBuf.InsertDtldCVLedgEntry(DtldCVLedgEntryBuf, NewCVLedgEntryBuf, true);                OnCalcPmtDiscIfAdjVATOnBeforeInsertSummarizedVATAfterLoop(DtldCVLedgEntryBuf, OldCVLedgEntryBuf);                InsertSummarizedVAT(GenJnlLine);            end;            PmtDiscLCY2 -= NonDedReverseChargeVATBasePmtDisc;            PmtDiscAddCurr2 -= NonDedReverseChargeVATBasePmtDiscACY;        end;        OnAfterCalcPmtDiscIfAdjVAT(NewCVLedgEntryBuf, OldCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine, PmtDiscLCY2, PmtDiscAddCurr2);    end;    local procedure CalcPmtDiscTolerance(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; NextTransactionNo: Integer; FirstNewVATEntryNo: Integer)    var        PmtDiscTol: Decimal;        PmtDiscTolLCY: Decimal;        PmtDiscTolAddCurr: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcPmtDiscTolerance(          NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine, IsHandled);        if IsHandled then            exit;        if not OldCVLedgEntryBuf2."Accepted Pmt. Disc. Tolerance" then            exit;        PmtDiscTol := -OldCVLedgEntryBuf2."Remaining Pmt. Disc. Possible";        PmtDiscTolLCY :=          Round(            (NewCVLedgEntryBuf."Original Amount" + PmtDiscTol) / NewCVLedgEntryBuf."Original Currency Factor") -          NewCVLedgEntryBuf."Original Amt. (LCY)";        OnAfterCalcPmtDiscTolerance(          NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine,          PmtDiscTol, PmtDiscTolLCY, PmtDiscTolAddCurr);        OldCVLedgEntryBuf."Pmt. Disc. Given (LCY)" := -PmtDiscTolLCY;        if NewCVLedgEntryBuf."Currency Code" = AddCurrencyCode then            PmtDiscTolAddCurr := PmtDiscTol        else            PmtDiscTolAddCurr := CalcLCYToAddCurr(PmtDiscTolLCY);        if not GLSetup."Pmt. Disc. Excl. VAT" and GLSetup."Adjust for Payment Disc." and (PmtDiscTolLCY <> 0) then            CalcPmtDiscIfAdjVAT(              NewCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine, PmtDiscTolLCY, PmtDiscTolAddCurr,              NextTransactionNo, FirstNewVATEntryNo, DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Excl.)");        OnCalcPmtDiscToleranceBeforeInitDetailedCVLedgEntryBuff(GenJnlLine, IsHandled);        if not IsHandled then            DtldCVLedgEntryBuf.InitDetailedCVLedgEntryBuf(                GenJnlLine, NewCVLedgEntryBuf, DtldCVLedgEntryBuf,                DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance", PmtDiscTol, PmtDiscTolLCY, PmtDiscTolAddCurr, 0, 0, 0);        OnAfterCalcPmtDiscToleranceProc(DtldCVLedgEntryBuf, OldCVLedgEntryBuf, PmtDiscTol, PmtDiscTolLCY, GenJnlLine);    end;    local procedure CalcPmtDiscVATBases(VATEntry2: Record "VAT Entry"; var VATBase: Decimal; var VATBaseAddCurr: Decimal; var NonDeductibleVATBase: Decimal; var NonDeductibleVATBaseAddCurr: Decimal)    var        VATEntry: Record "VAT Entry";    begin        case VATEntry2."VAT Calculation Type" of            VATEntry2."VAT Calculation Type"::"Normal VAT",            VATEntry2."VAT Calculation Type"::"Reverse Charge VAT",            VATEntry2."VAT Calculation Type"::"Full VAT":                begin                    VATBase :=                      VATEntry2.Base + VATEntry2."Unrealized Base";                    VATBaseAddCurr :=                      VATEntry2."Additional-Currency Base" +                      VATEntry2."Add.-Currency Unrealized Base";                    NonDeductibleVAT.GetNonDeductibleVATBaseBothCurrencies(NonDeductibleVATBase, NonDeductibleVATBaseAddCurr, VATEntry2);                end;            VATEntry2."VAT Calculation Type"::"Sales Tax":                begin                    VATEntry.Reset();                    VATEntry.SetCurrentKey("Transaction No.");                    VATEntry.SetRange("Transaction No.", VATEntry2."Transaction No.");                    VATEntry.SetRange("Sales Tax Connection No.", VATEntry2."Sales Tax Connection No.");                    VATEntry := VATEntry2;                    repeat                        if VATEntry.Base < 0 then                            VATEntry.SetFilter(Base, '>%1', VATEntry.Base)                        else                            VATEntry.SetFilter(Base, '<%1', VATEntry.Base);                    until not VATEntry.FindLast();                    VATEntry.Reset();                    VATBase :=                      VATEntry.Base + VATEntry."Unrealized Base";                    VATBaseAddCurr :=                      VATEntry."Additional-Currency Base" +                      VATEntry."Add.-Currency Unrealized Base";                end;        end;        OnAfterCalcPmtDiscVATBases(VATEntry2, VATBase, VATBaseAddCurr, NonDeductibleVATBase, NonDeductibleVATBaseAddCurr);    end;    local procedure CalcPmtDiscVATAmounts(VATEntry2: Record "VAT Entry"; VATBase: Decimal; VATBaseAddCurr: Decimal; NonDedVATBase: Decimal; NonDedVATBaseAddCurr: Decimal; var VATAmount: Decimal; var VATAmountAddCurr: Decimal; var NonDedVATAmount: Decimal; var NonDedVATAmountAddCurr: Decimal; var PmtDiscRounding: Decimal; PmtDiscFactorLCY: Decimal; var PmtDiscLCY2: Decimal; var PmtDiscAddCurr2: Decimal)    begin        case VATEntry2."VAT Calculation Type" of            VATEntry2."VAT Calculation Type"::"Normal VAT",          VATEntry2."VAT Calculation Type"::"Full VAT":                if (VATEntry2.Amount + VATEntry2."Unrealized Amount" + VATEntry2."Non-Deductible VAT Amount" <> 0) or                   (VATEntry2."Additional-Currency Amount" + VATEntry2."Add.-Currency Unrealized Amt." + VATEntry2."Non-Deductible VAT Amount ACY" <> 0)                then begin                    if (VATBase = 0) and                       (VATEntry2."VAT Calculation Type" <> VATEntry2."VAT Calculation Type"::"Full VAT")                    then                        VATAmount := 0                    else                        VATAmount :=                            CalcAmtMultipliedByFactorWithRounding(                                PmtDiscRounding, PmtDiscLCY2, VATEntry2.Amount + VATEntry2."Unrealized Amount", PmtDiscFactorLCY);                    if (VATBaseAddCurr = 0) and                       (VATEntry2."VAT Calculation Type" <> VATEntry2."VAT Calculation Type"::"Full VAT")                    then                        VATAmountAddCurr := 0                    else begin                        VATAmountAddCurr := Round(CalcLCYToAddCurr(VATAmount), AddCurrency."Amount Rounding Precision");                        PmtDiscAddCurr2 := PmtDiscAddCurr2 + VATAmountAddCurr;                    end;                    if (NonDedVATBase = 0) and                       (VATEntry2."VAT Calculation Type" <> VATEntry2."VAT Calculation Type"::"Full VAT")                    then                        NonDedVATAmount := 0                    else                        NonDedVATAmount :=                            CalcAmtMultipliedByFactorWithRounding(                                PmtDiscRounding, PmtDiscLCY2, VATEntry2."Non-Deductible VAT Amount", PmtDiscFactorLCY);                    if (NonDedVATBaseAddCurr = 0) and                       (VATEntry2."VAT Calculation Type" <> VATEntry2."VAT Calculation Type"::"Full VAT")                    then                        NonDedVATAmountAddCurr := 0                    else begin                        NonDedVATAmountAddCurr := Round(CalcLCYToAddCurr(NonDedVATAmount), AddCurrency."Amount Rounding Precision");                        PmtDiscAddCurr2 := PmtDiscAddCurr2 + NonDedVATAmountAddCurr;                    end;                end else begin                    VATAmount := 0;                    VATAmountAddCurr := 0;                    NonDedVATAmount := 0;                    NonDedVATAmountAddCurr := 0;                end;            VATEntry2."VAT Calculation Type"::"Reverse Charge VAT":                begin                    VATAmount :=                        Round((VATEntry2.Amount + VATEntry2."Unrealized Amount") * PmtDiscFactorLCY);                    VATAmountAddCurr := Round(CalcLCYToAddCurr(VATAmount), AddCurrency."Amount Rounding Precision");                    NonDedVATAmount :=                        Round(VATEntry2."Non-Deductible VAT Amount" * PmtDiscFactorLCY);                    NonDedVATAmountAddCurr := Round(CalcLCYToAddCurr(NonDedVATAmount), AddCurrency."Amount Rounding Precision");                    if PmtDiscLCY2 = 0 then                        PmtDiscAddCurr2 := 0                end;            VATEntry2."VAT Calculation Type"::"Sales Tax":                if (VATEntry2.Type = VATEntry2.Type::Purchase) and VATEntry2."Use Tax" then begin                    VATAmount :=                      Round((VATEntry2.Amount + VATEntry2."Unrealized Amount") * PmtDiscFactorLCY);                    VATAmountAddCurr := Round(CalcLCYToAddCurr(VATAmount), AddCurrency."Amount Rounding Precision");                end else                    if (VATEntry2.Amount + VATEntry2."Unrealized Amount" <> 0) or                       (VATEntry2."Additional-Currency Amount" + VATEntry2."Add.-Currency Unrealized Amt." <> 0)                    then begin                        if VATBase = 0 then                            VATAmount := 0                        else                            VATAmount :=                                CalcAmtMultipliedByFactorWithRounding(                                    PmtDiscRounding, PmtDiscLCY2, VATEntry2.Amount + VATEntry2."Unrealized Amount", PmtDiscFactorLCY);                        if VATBaseAddCurr = 0 then                            VATAmountAddCurr := 0                        else begin                            VATAmountAddCurr := Round(CalcLCYToAddCurr(VATAmount), AddCurrency."Amount Rounding Precision");                            PmtDiscAddCurr2 := PmtDiscAddCurr2 + VATAmountAddCurr;                        end;                    end else begin                        VATAmount := 0;                        VATAmountAddCurr := 0;                    end;        end;    end;    local procedure CalcAmtMultipliedByFactorWithRounding(var Rounding: Decimal; var TotalAmount: Decimal; SourceAmount: Decimal; Factor: Decimal) Result: Decimal    begin        Rounding := Rounding + SourceAmount * Factor;        Result := Round(Rounding - TotalAmount);        TotalAmount := TotalAmount + Result;    end;    internal procedure CalcAmountSourceCurrency(var GenJnlLine: Record "Gen. Journal Line"; AmountLCY: Decimal): Decimal    begin        CalcAmountSrcCurr(GenJnlLine, AmountLCY);    end;    local procedure CalcAmountSrcCurr(var GenJnlLine: Record "Gen. Journal Line"; AmountLCY: Decimal): Decimal    var        SrcCurrencyFactor: Decimal;        LocalAmountRoundingPrecision: Decimal;    begin        if GenJnlLine."Currency Factor" = 0 then            SrcCurrencyFactor := CurrExchRate.ExchangeRate(GenJnlLine."Posting Date", GenJnlLine."Source Currency Code")        else            SrcCurrencyFactor := GenJnlLine."Currency Factor";        // Ensure AmountRoundingPrecision is initialized when called externally        if AmountRoundingPrecision = 0 then            LocalAmountRoundingPrecision := GetSourceCurrency(GenJnlLine."Source Currency Code")        else            LocalAmountRoundingPrecision := AmountRoundingPrecision;        exit(          Round(            CurrExchRate.ExchangeAmtLCYToFCY(                GenJnlLine."Posting Date", GenJnlLine."Source Currency Code", AmountLCY, SrcCurrencyFactor), LocalAmountRoundingPrecision));    end;    local procedure InsertPmtDiscVATForVATEntry(GenJnlLine: Record "Gen. Journal Line"; var TempVATEntry: Record "VAT Entry" temporary; VATEntry2: Record "VAT Entry"; VATEntryModifier: Integer; VATAmount: Decimal; VATAmountAddCurr: Decimal; VATBase: Decimal; VATBaseAddCurr: Decimal; NonDedVATAmount: Decimal; NonDedVATAmountAddCurr: Decimal; NonDedVATBase: Decimal; NonDedVATBaseAddCurr: Decimal; PmtDiscFactorLCY: Decimal; PmtDiscFactorAddCurr: Decimal)    var        TempVATEntryNo: Integer;    begin        TempVATEntry.Reset();        TempVATEntry.SetRange("Entry No.", VATEntryModifier, VATEntryModifier + 999999);        if TempVATEntry.FindLast() then            TempVATEntryNo := TempVATEntry."Entry No." + 1        else            TempVATEntryNo := VATEntryModifier + 1;        TempVATEntry := VATEntry2;        TempVATEntry."Entry No." := TempVATEntryNo;        TempVATEntry.CopyPostingDataFromGenJnlLine(GenJnlLine);        TempVATEntry.SetVATDateFromGenJnlLine(GenJnlLine);        TempVATEntry."Transaction No." := NextTransactionNo;        TempVATEntry."Sales Tax Connection No." := NextConnectionNo;        TempVATEntry."Unrealized Amount" := 0;        TempVATEntry."Unrealized Base" := 0;        TempVATEntry."Remaining Unrealized Amount" := 0;        TempVATEntry."Remaining Unrealized Base" := 0;        TempVATEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(TempVATEntry."User ID"));        TempVATEntry."Closed by Entry No." := 0;        TempVATEntry.Closed := false;        TempVATEntry."Internal Ref. No." := '';        TempVATEntry.Amount := VATAmount;        TempVATEntry."Additional-Currency Amount" := VATAmountAddCurr;        NonDeductibleVAT.SetNonDeductibleVATAmount(TempVATEntry, NonDedVATAmount, NonDedVATAmountAddCurr);        TempVATEntry."VAT Difference" := 0;        TempVATEntry."Add.-Curr. VAT Difference" := 0;        TempVATEntry."Add.-Currency Unrealized Amt." := 0;        TempVATEntry."Add.-Currency Unrealized Base" := 0;        if VATEntry2."Tax on Tax" then begin            TempVATEntry.Base :=              Round((VATEntry2.Base + VATEntry2."Unrealized Base") * PmtDiscFactorLCY);            TempVATEntry."Additional-Currency Base" :=              Round(                (VATEntry2."Additional-Currency Base" +                 VATEntry2."Add.-Currency Unrealized Base") * PmtDiscFactorAddCurr,                AddCurrency."Amount Rounding Precision");        end else begin            TempVATEntry.Base := VATBase;            TempVATEntry."Additional-Currency Base" := VATBaseAddCurr;            NonDeductibleVAT.SetNonDeductibleVATBase(TempVATEntry, NonDedVATBase, NonDedVATBaseAddCurr);        end;        TempVATEntry."Base Before Pmt. Disc." := VATEntry.Base;        if AddCurrencyCode = '' then begin            TempVATEntry."Additional-Currency Base" := 0;            TempVATEntry."Additional-Currency Amount" := 0;            TempVATEntry."Add.-Currency Unrealized Amt." := 0;            TempVATEntry."Add.-Currency Unrealized Base" := 0;        end;        TempVATEntry."G/L Acc. No." := '';        OnBeforeInsertTempVATEntry(TempVATEntry, GenJnlLine, VATEntry2, VATAmount, VATBase);        TempVATEntry.Insert();    end;    local procedure InsertPmtDiscVATForGLEntry(GenJnlLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; VATEntry2: Record "VAT Entry"; var VATPostingSetup: Record "VAT Posting Setup"; var TaxJurisdiction: Record "Tax Jurisdiction"; EntryType: Enum "Detailed CV Ledger Entry Type"; VATAmount: Decimal; VATAmountAddCurr: Decimal; NonDedVATAmount: Decimal; NonDedVATAmountAddCurr: Decimal)    var        NonDedVATAccountNo: Code[20];        IsHandled: Boolean;    begin        DtldCVLedgEntryBuf.Init();        DtldCVLedgEntryBuf.CopyFromCVLedgEntryBuf(NewCVLedgEntryBuf);        case EntryType of            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Excl.)":                DtldCVLedgEntryBuf."Entry Type" :=                  DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Adjustment)";            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Excl.)":                DtldCVLedgEntryBuf."Entry Type" :=                  DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Adjustment)";            DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Excl.)":                DtldCVLedgEntryBuf."Entry Type" :=                  DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Adjustment)";        end;        DtldCVLedgEntryBuf."Posting Date" := GenJnlLine."Posting Date";        DtldCVLedgEntryBuf."Document Type" := GenJnlLine."Document Type";        DtldCVLedgEntryBuf."Document No." := GenJnlLine."Document No.";        OnInsertPmtDiscVATForGLEntryOnAfterCopyFromGenJnlLine(DtldCVLedgEntryBuf, GenJnlLine);        DtldCVLedgEntryBuf.Amount := 0;        DtldCVLedgEntryBuf."VAT Bus. Posting Group" := VATEntry2."VAT Bus. Posting Group";        DtldCVLedgEntryBuf."VAT Prod. Posting Group" := VATEntry2."VAT Prod. Posting Group";        DtldCVLedgEntryBuf."Tax Jurisdiction Code" := VATEntry2."Tax Jurisdiction Code";        // The total payment discount in currency is posted on the entry made in        // the function CalcPmtDisc.        DtldCVLedgEntryBuf."User ID" := CopyStr(UserId(), 1, MaxStrLen(DtldCVLedgEntryBuf."User ID"));        DtldCVLedgEntryBuf."Use Additional-Currency Amount" := true;        IsHandled := false;        OnBeforeInsertPmtDiscVATForGLEntry(DtldCVLedgEntryBuf, GenJnlLine, VATEntry2, VATPostingSetup, VATAmount, VATAmountAddCurr, NewCVLedgEntryBuf, TempGLEntryVAT, IsHandled, NonDedVATAmount, NonDedVATAmountAddCurr);        if not IsHandled then            case VATEntry2.Type of                VATEntry2.Type::Purchase:                    case VATEntry2."VAT Calculation Type" of                        VATEntry2."VAT Calculation Type"::"Normal VAT",                        VATEntry2."VAT Calculation Type"::"Full VAT":                            begin                                InitGLEntryVAT(GenJnlLine, VATPostingSetup.GetPurchAccount(false), '',                                  VATAmount, VATAmountAddCurr, false);                                DtldCVLedgEntryBuf."Amount (LCY)" := -VATAmount;                                DtldCVLedgEntryBuf."Additional-Currency Amount" := -VATAmountAddCurr;                                DtldCVLedgEntryBuf.InsertDtldCVLedgEntry(DtldCVLedgEntryBuf, NewCVLedgEntryBuf, true);                            end;                        VATEntry2."VAT Calculation Type"::"Reverse Charge VAT":                            begin                                InitGLEntryVAT(GenJnlLine, VATPostingSetup.GetPurchAccount(false), '',                                  VATAmount, VATAmountAddCurr, false);                                InitGLEntryVAT(GenJnlLine, VATPostingSetup.GetRevChargeAccount(false), '',                                  -VATAmount, -VATAmountAddCurr, false);                                if NonDedVATAmount <> 0 then begin                                    NonDedVATAccountNo := VATPostingSetup.GetPurchAccount(false);                                    if EntryType = EntryType::"Payment Discount (VAT Excl.)" then                                        NonDedVATAccountNo := GetPaymentDiscountVATExclNonDedVATAccountNo(VATEntry2, NonDedVATAmount);                                    InitGLEntryVAT(GenJnlLine, NonDedVATAccountNo, '',                                    NonDedVATAmount, NonDedVATAmountAddCurr, false);                                    InitGLEntryVAT(GenJnlLine, VATPostingSetup.GetRevChargeAccount(false), '',                                    -NonDedVATAmount, -NonDedVATAmountAddCurr, false);                                end;                            end;                        VATEntry2."VAT Calculation Type"::"Sales Tax":                            if VATEntry2."Use Tax" then begin                                InitGLEntryVAT(GenJnlLine, TaxJurisdiction.GetPurchAccount(false), '',                                  VATAmount, VATAmountAddCurr, false);                                InitGLEntryVAT(GenJnlLine, TaxJurisdiction.GetRevChargeAccount(false), '',                                  -VATAmount, -VATAmountAddCurr, false);                            end else begin                                InitGLEntryVAT(GenJnlLine, TaxJurisdiction.GetPurchAccount(false), '',                                  VATAmount, VATAmountAddCurr, false);                                DtldCVLedgEntryBuf."Amount (LCY)" := -VATAmount;                                DtldCVLedgEntryBuf."Additional-Currency Amount" := -VATAmountAddCurr;                                DtldCVLedgEntryBuf.InsertDtldCVLedgEntry(DtldCVLedgEntryBuf, NewCVLedgEntryBuf, true);                            end;                    end;                VATEntry2.Type::Sale:                    case VATEntry2."VAT Calculation Type" of                        VATEntry2."VAT Calculation Type"::"Normal VAT",                        VATEntry2."VAT Calculation Type"::"Full VAT":                            begin                                InitGLEntryVAT(                                  GenJnlLine, VATPostingSetup.GetSalesAccount(false), '',                                  VATAmount, VATAmountAddCurr, false);                                DtldCVLedgEntryBuf."Amount (LCY)" := -VATAmount;                                DtldCVLedgEntryBuf."Additional-Currency Amount" := -VATAmountAddCurr;                                DtldCVLedgEntryBuf.InsertDtldCVLedgEntry(DtldCVLedgEntryBuf, NewCVLedgEntryBuf, true);                            end;                        VATEntry2."VAT Calculation Type"::"Reverse Charge VAT":                            ;                        VATEntry2."VAT Calculation Type"::"Sales Tax":                            begin                                InitGLEntryVAT(                                  GenJnlLine, TaxJurisdiction.GetSalesAccount(false), '',                                  VATAmount, VATAmountAddCurr, false);                                DtldCVLedgEntryBuf."Amount (LCY)" := -VATAmount;                                DtldCVLedgEntryBuf."Additional-Currency Amount" := -VATAmountAddCurr;                                DtldCVLedgEntryBuf.InsertDtldCVLedgEntry(DtldCVLedgEntryBuf, NewCVLedgEntryBuf, true);                            end;                    end;            end;        OnAfterInsertPmtDiscVATForGLEntry(DtldCVLedgEntryBuf, GenJnlLine);    end;    local procedure CalcCurrencyApplnRounding(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; ApplnRoundingPrecision: Decimal)    var        ApplnRounding: Decimal;        ApplnRoundingLCY: Decimal;    begin        if NewCVLedgEntryBuf."Currency Code" = OldCVLedgEntryBuf."Currency Code" then            exit;        ApplnRounding := -(NewCVLedgEntryBuf."Remaining Amount" + OldCVLedgEntryBuf."Remaining Amount");        ApplnRoundingLCY := Round(ApplnRounding / NewCVLedgEntryBuf."Adjusted Currency Factor");        if (ApplnRounding = 0) or (Abs(ApplnRounding) > ApplnRoundingPrecision) then            exit;        DtldCVLedgEntryBuf.InitDetailedCVLedgEntryBuf(          GenJnlLine, NewCVLedgEntryBuf, DtldCVLedgEntryBuf,          DtldCVLedgEntryBuf."Entry Type"::"Appln. Rounding", ApplnRounding, ApplnRoundingLCY, ApplnRounding, 0, 0, 0);    end;    local procedure FindAmtForAppln(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var AppliedAmount: Decimal; var AppliedAmountLCY: Decimal; var OldAppliedAmount: Decimal; ApplnRoundingPrecision: Decimal; var GenJournalLine: Record "Gen. Journal Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeFindAmtForAppln(          NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, AppliedAmount, AppliedAmountLCY, OldAppliedAmount, IsHandled,          ApplnRoundingPrecision, VATEntry);        if IsHandled then            exit;        if OldCVLedgEntryBuf2.GetFilter(Positive) <> '' then begin            if OldCVLedgEntryBuf2."Amount to Apply" <> 0 then begin                if (PaymentToleranceMgt.CheckCalcPmtDisc(NewCVLedgEntryBuf, OldCVLedgEntryBuf2, ApplnRoundingPrecision, false, false) and                    (Abs(OldCVLedgEntryBuf2."Amount to Apply") >=                     Abs(OldCVLedgEntryBuf2."Remaining Amount" - OldCVLedgEntryBuf2."Remaining Pmt. Disc. Possible")))                then begin                    AppliedAmount := -OldCVLedgEntryBuf2."Remaining Amount";                    OnAfterSetAppliedAmountFromRemainingAmount(OldCVLedgEntryBuf2, AppliedAmount, GenJournalLine)                end else                    AppliedAmount := -OldCVLedgEntryBuf2."Amount to Apply"            end else                AppliedAmount := -OldCVLedgEntryBuf2."Remaining Amount";        end else            if OldCVLedgEntryBuf2."Amount to Apply" <> 0 then                if (PaymentToleranceMgt.CheckCalcPmtDisc(NewCVLedgEntryBuf, OldCVLedgEntryBuf2, ApplnRoundingPrecision, false, false) and                    (Abs(OldCVLedgEntryBuf2."Amount to Apply") >=                     Abs(OldCVLedgEntryBuf2."Remaining Amount" - OldCVLedgEntryBuf2.GetRemainingPmtDiscPossible(NewCVLedgEntryBuf."Posting Date"))) and                    (Abs(NewCVLedgEntryBuf."Remaining Amount") >=                     Abs(                       ABSMin(                         OldCVLedgEntryBuf2."Remaining Amount" - OldCVLedgEntryBuf2.GetRemainingPmtDiscPossible(NewCVLedgEntryBuf."Posting Date"),                         OldCVLedgEntryBuf2."Amount to Apply")))) or                   OldCVLedgEntryBuf."Accepted Pmt. Disc. Tolerance"                then begin                    AppliedAmount := -OldCVLedgEntryBuf2."Remaining Amount";                    OnAfterSetAppliedAmountFromRemainingAmountOnEmptyFilter(OldCVLedgEntryBuf2, AppliedAmount, GenJournalLine);                    OldCVLedgEntryBuf."Accepted Pmt. Disc. Tolerance" := false;                end else                    AppliedAmount := ABSMin(NewCVLedgEntryBuf."Remaining Amount", -OldCVLedgEntryBuf2."Amount to Apply")            else                AppliedAmount := ABSMin(NewCVLedgEntryBuf."Remaining Amount", -OldCVLedgEntryBuf2."Remaining Amount");        if (Abs(OldCVLedgEntryBuf2."Remaining Amount" - OldCVLedgEntryBuf2."Amount to Apply") < ApplnRoundingPrecision) and           (ApplnRoundingPrecision <> 0) and           (OldCVLedgEntryBuf2."Amount to Apply" <> 0)        then            AppliedAmount := AppliedAmount - (OldCVLedgEntryBuf2."Remaining Amount" - OldCVLedgEntryBuf2."Amount to Apply");        if NewCVLedgEntryBuf."Currency Code" = OldCVLedgEntryBuf2."Currency Code" then begin            AppliedAmountLCY := Round(AppliedAmount / OldCVLedgEntryBuf."Original Currency Factor");            OldAppliedAmount := AppliedAmount;        end else begin            // Management of posting in multiple currencies            if AppliedAmount = -OldCVLedgEntryBuf2."Remaining Amount" then                OldAppliedAmount := -OldCVLedgEntryBuf."Remaining Amount"            else                OldAppliedAmount :=                  CurrExchRate.ExchangeAmount(                    AppliedAmount, NewCVLedgEntryBuf."Currency Code",                    OldCVLedgEntryBuf2."Currency Code", NewCVLedgEntryBuf."Posting Date");            if NewCVLedgEntryBuf."Currency Code" <> '' then                // Post the realized gain or loss on the NewCVLedgEntryBuf                AppliedAmountLCY := Round(OldAppliedAmount / OldCVLedgEntryBuf."Original Currency Factor")            else                // Post the realized gain or loss on the OldCVLedgEntryBuf                AppliedAmountLCY := Round(AppliedAmount / NewCVLedgEntryBuf."Original Currency Factor");        end;        OnAfterFindAmtForAppln(          NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, AppliedAmount,          AppliedAmountLCY, OldAppliedAmount, AmountRoundingPrecision, VATEntry);    end;    /// <summary>    /// Calculates unrealized gains and losses, if there are any then detailed CV ledger entries are created.    /// </summary>    /// <param name="CVLedgEntryBuf">Return value: CV ledger entry buffer that detailed entries are created for. In the procedure amounts are modified to reflect the application.</param>    /// <param name="TempDtldCVLedgEntryBuf">Return value: Buffer where created CV ledger entries should be inserted to.</param>    /// <param name="GenJnlLine">Gen. journal line that is being posted.</param>    /// <param name="AppliedAmount">Amount that is being applied.</param>    /// <param name="RemainingAmountBeforeAppln">Remaining amount on the ledger entry that the application is performed to.</param>    procedure CalcCurrencyUnrealizedGainLoss(var CVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary; GenJnlLine: Record "Gen. Journal Line"; AppliedAmount: Decimal; RemainingAmountBeforeAppln: Decimal)    var        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry";        DtldEmplLedgEntry: Record "Detailed Employee Ledger Entry";        UnRealizedGainLossLCY: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcCurrencyUnrealizedGainLoss(          CVLedgEntryBuf, TempDtldCVLedgEntryBuf, GenJnlLine, AppliedAmount, RemainingAmountBeforeAppln, IsHandled);        if IsHandled then            exit;        if (CVLedgEntryBuf."Currency Code" = '') or (RemainingAmountBeforeAppln = 0) then            exit;        // Calculate Unrealized GainLoss        case GenJnlLine."Account Type" of            GenJnlLine."Account Type"::Customer:                UnRealizedGainLossLCY :=                    Round(                        DtldCustLedgEntry.GetUnrealizedGainLossAmount(CVLedgEntryBuf."Entry No.") *                        Abs(AppliedAmount / RemainingAmountBeforeAppln));            GenJnlLine."Account Type"::Employee:                UnRealizedGainLossLCY :=                    Round(                        DtldEmplLedgEntry.GetUnrealizedGainLossAmount(CVLedgEntryBuf."Entry No.") *                        Abs(AppliedAmount / RemainingAmountBeforeAppln));            else                UnRealizedGainLossLCY :=                    Round(                        DtldVendLedgEntry.GetUnrealizedGainLossAmount(CVLedgEntryBuf."Entry No.") *                        Abs(AppliedAmount / RemainingAmountBeforeAppln));        end;        if UnRealizedGainLossLCY <> 0 then            if UnRealizedGainLossLCY < 0 then                TempDtldCVLedgEntryBuf.InitDetailedCVLedgEntryBuf(                  GenJnlLine, CVLedgEntryBuf, TempDtldCVLedgEntryBuf,                  TempDtldCVLedgEntryBuf."Entry Type"::"Unrealized Loss", 0, -UnRealizedGainLossLCY, 0, 0, 0, 0)            else                TempDtldCVLedgEntryBuf.InitDetailedCVLedgEntryBuf(                  GenJnlLine, CVLedgEntryBuf, TempDtldCVLedgEntryBuf,                  TempDtldCVLedgEntryBuf."Entry Type"::"Unrealized Gain", 0, -UnRealizedGainLossLCY, 0, 0, 0, 0);    end;    local procedure CalcCurrencyRealizedGainLoss(var CVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary; GenJnlLine: Record "Gen. Journal Line"; AppliedAmount: Decimal; AppliedAmountLCY: Decimal)    var        RealizedGainLossLCY: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcCurrencyRealizedGainLoss(          CVLedgEntryBuf, TempDtldCVLedgEntryBuf, GenJnlLine, AppliedAmount, AppliedAmountLCY, IsHandled);        if IsHandled then            exit;        if CVLedgEntryBuf."Currency Code" = '' then            exit;        RealizedGainLossLCY := AppliedAmountLCY - Round(AppliedAmount / CVLedgEntryBuf."Original Currency Factor");        OnAfterCalcCurrencyRealizedGainLoss(CVLedgEntryBuf, AppliedAmount, AppliedAmountLCY, RealizedGainLossLCY);        if RealizedGainLossLCY <> 0 then            if RealizedGainLossLCY < 0 then                TempDtldCVLedgEntryBuf.InitDetailedCVLedgEntryBuf(                  GenJnlLine, CVLedgEntryBuf, TempDtldCVLedgEntryBuf,                  TempDtldCVLedgEntryBuf."Entry Type"::"Realized Loss", 0, RealizedGainLossLCY, 0, 0, 0, 0)            else                TempDtldCVLedgEntryBuf.InitDetailedCVLedgEntryBuf(                  GenJnlLine, CVLedgEntryBuf, TempDtldCVLedgEntryBuf,                  TempDtldCVLedgEntryBuf."Entry Type"::"Realized Gain", 0, RealizedGainLossLCY, 0, 0, 0, 0);    end;    local procedure CalcApplication(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; AppliedAmount: Decimal; AppliedAmountLCY: Decimal; OldAppliedAmount: Decimal; PrevNewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; PrevOldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var AllApplied: Boolean)    var        IsHandled: Boolean;        ShouldSetClosedFields: Boolean;    begin        IsHandled := false;        OnBeforeCalcAplication(          NewCVLedgEntryBuf, OldCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine,          AppliedAmount, AppliedAmountLCY, OldAppliedAmount, PrevNewCVLedgEntryBuf, PrevOldCVLedgEntryBuf, AllApplied, IsHandled);        if IsHandled then            exit;        OnCalcApplicationOnBeforeCheckAppliedAmount(GenJnlLine, AppliedAmount, IsHandled);        if not IsHandled then            if AppliedAmount = 0 then                exit;        DtldCVLedgEntryBuf.InitDetailedCVLedgEntryBuf(          GenJnlLine, OldCVLedgEntryBuf, DtldCVLedgEntryBuf,          DtldCVLedgEntryBuf."Entry Type"::Application, OldAppliedAmount, AppliedAmountLCY, 0,          NewCVLedgEntryBuf."Entry No.", PrevOldCVLedgEntryBuf."Remaining Pmt. Disc. Possible",          PrevOldCVLedgEntryBuf."Max. Payment Tolerance");        OnAfterInitOldDtldCVLedgEntryBuf(          DtldCVLedgEntryBuf, NewCVLedgEntryBuf, OldCVLedgEntryBuf, PrevNewCVLedgEntryBuf, PrevOldCVLedgEntryBuf, GenJnlLine);        OldCVLedgEntryBuf.Open := OldCVLedgEntryBuf."Remaining Amount" <> 0;        OnCalcApplicationOnAfterFillOldCVLedgEntryBufOpen(GenJnlLine, OldCVLedgEntryBuf);        if not OldCVLedgEntryBuf.Open then            OldCVLedgEntryBuf.SetClosedFields(              NewCVLedgEntryBuf."Entry No.", GenJnlLine."Posting Date",              -OldAppliedAmount, -AppliedAmountLCY, NewCVLedgEntryBuf."Currency Code", -AppliedAmount)        else            AllApplied := false;        DtldCVLedgEntryBuf.InitDetailedCVLedgEntryBuf(          GenJnlLine, NewCVLedgEntryBuf, DtldCVLedgEntryBuf,          DtldCVLedgEntryBuf."Entry Type"::Application, -AppliedAmount, -AppliedAmountLCY, 0,          NewCVLedgEntryBuf."Entry No.", PrevNewCVLedgEntryBuf."Remaining Pmt. Disc. Possible",          PrevNewCVLedgEntryBuf."Max. Payment Tolerance");        OnAfterInitNewDtldCVLedgEntryBuf(          DtldCVLedgEntryBuf, NewCVLedgEntryBuf, OldCVLedgEntryBuf, PrevNewCVLedgEntryBuf, PrevOldCVLedgEntryBuf, GenJnlLine);        NewCVLedgEntryBuf.Open := NewCVLedgEntryBuf."Remaining Amount" <> 0;        ShouldSetClosedFields := not NewCVLedgEntryBuf.Open and not AllApplied;        OnCalcApplicationOnAfterCalcShouldSetClosedFields(NewCVLedgEntryBuf, ShouldSetClosedFields);        if ShouldSetClosedFields then            NewCVLedgEntryBuf.SetClosedFields(              OldCVLedgEntryBuf."Entry No.", GenJnlLine."Posting Date",              AppliedAmount, AppliedAmountLCY, OldCVLedgEntryBuf."Currency Code", OldAppliedAmount);        if not NewCVLedgEntryBuf.Open then            NewCVLedgEntryBuf."Closed at Date" := GenJnlLine."Posting Date";        OnAfterCalcApplication(GenJnlLine, DtldCVLedgEntryBuf);    end;    /// <summary>    /// Calculates the difference in local currency between the actual remaining amount of the c/v ledger entry and the remaining amount based on the adjusted currency factor.    /// If there is a difference then detailed CV ledger entries are created and posted to equate the difference.    /// </summary>    /// <param name="CVLedgEntryBuf">Cv ledger entry that the adjustment should be calculated for.</param>    /// <param name="DtldCVLedgEntryBuf">Buffer table for detailed vendor ledger entries to be posted.</param>    /// <param name="GenJnlLine">Gen. journal line that is being posted.</param>    procedure CalcAmtLCYAdjustment(var CVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line")    var        AdjustedAmountLCY: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcAmtLCYAdjustment(CVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine, IsHandled);        if IsHandled then            exit;        if CVLedgEntryBuf."Currency Code" = '' then            exit;        AdjustedAmountLCY :=          Round(CVLedgEntryBuf."Remaining Amount" / CVLedgEntryBuf."Adjusted Currency Factor");        if AdjustedAmountLCY <> CVLedgEntryBuf."Remaining Amt. (LCY)" then begin            DtldCVLedgEntryBuf.InitFromGenJnlLine(GenJnlLine);            DtldCVLedgEntryBuf.CopyFromCVLedgEntryBuf(CVLedgEntryBuf);            DtldCVLedgEntryBuf."Entry Type" :=              DtldCVLedgEntryBuf."Entry Type"::"Correction of Remaining Amount";            DtldCVLedgEntryBuf."Amount (LCY)" := AdjustedAmountLCY - CVLedgEntryBuf."Remaining Amt. (LCY)";            DtldCVLedgEntryBuf.InsertDtldCVLedgEntry(DtldCVLedgEntryBuf, CVLedgEntryBuf, false);        end;    end;    local procedure InitBankAccLedgEntry(GenJnlLine: Record "Gen. Journal Line"; var BankAccLedgEntry: Record "Bank Account Ledger Entry")    begin        OnBeforeInitBankAccLedgEntry(BankAccLedgEntry, GenJnlLine);        BankAccLedgEntry.Init();        BankAccLedgEntry.CopyFromGenJnlLine(GenJnlLine);        BankAccLedgEntry."Entry No." := NextEntryNo;        BankAccLedgEntry."Transaction No." := NextTransactionNo;        OnAfterInitBankAccLedgEntry(BankAccLedgEntry, GenJnlLine);    end;    local procedure InitCheckLedgEntry(BankAccLedgEntry: Record "Bank Account Ledger Entry"; var CheckLedgEntry: Record "Check Ledger Entry")    begin        OnBeforeInitCheckEntry(BankAccLedgEntry, CheckLedgEntry);        CheckLedgEntry.Init();        CheckLedgEntry.CopyFromBankAccLedgEntry(BankAccLedgEntry);        CheckLedgEntry."Entry No." := NextCheckEntryNo;        OnAfterInitCheckLedgEntry(CheckLedgEntry, BankAccLedgEntry);    end;    local procedure InitCustLedgEntry(GenJnlLine: Record "Gen. Journal Line"; var CustLedgEntry: Record "Cust. Ledger Entry")    begin        OnBeforeInitCustLedgEntry(CustLedgEntry, GenJnlLine);        CustLedgEntry.Init();        CustLedgEntry.CopyFromGenJnlLine(GenJnlLine);        CustLedgEntry."Entry No." := NextEntryNo;        CustLedgEntry."Transaction No." := NextTransactionNo;        OnAfterInitCustLedgEntry(CustLedgEntry, GenJnlLine, GLReg);    end;    local procedure InitVendLedgEntry(GenJnlLine: Record "Gen. Journal Line"; var VendLedgEntry: Record "Vendor Ledger Entry")    begin        OnBeforeInitVendLedgEntry(VendLedgEntry, GenJnlLine);        VendLedgEntry.Init();        VendLedgEntry.CopyFromGenJnlLine(GenJnlLine);        VendLedgEntry."Entry No." := NextEntryNo;        VendLedgEntry."Transaction No." := NextTransactionNo;        OnAfterInitVendLedgEntry(VendLedgEntry, GenJnlLine, GLReg);    end;    local procedure InitEmployeeLedgerEntry(GenJnlLine: Record "Gen. Journal Line"; var EmployeeLedgerEntry: Record "Employee Ledger Entry")    begin        OnBeforeInitEmployeeLedgEntry(EmployeeLedgerEntry, GenJnlLine);        EmployeeLedgerEntry.Init();        EmployeeLedgerEntry.CopyFromGenJnlLine(GenJnlLine);        EmployeeLedgerEntry."Entry No." := NextEntryNo;        EmployeeLedgerEntry."Transaction No." := NextTransactionNo;        OnAfterInitEmployeeLedgerEntry(EmployeeLedgerEntry, GenJnlLine);    end;    local procedure InsertDtldCustLedgEntry(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; Offset: Integer)    var        CustLedgerEntry2: Record "Cust. Ledger Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertDtldCustLedgEntryProcedure(GenJnlLine, DtldCVLedgEntryBuf, DtldCustLedgEntry, IsHandled);        if IsHandled then            exit;        DtldCustLedgEntry.Init();        DtldCustLedgEntry.TransferFields(DtldCVLedgEntryBuf);        DtldCustLedgEntry."Entry No." := Offset + DtldCVLedgEntryBuf."Entry No.";        DtldCustLedgEntry."Journal Batch Name" := GenJnlLine."Journal Batch Name";        DtldCustLedgEntry."Reason Code" := GenJnlLine."Reason Code";        DtldCustLedgEntry."Source Code" := GenJnlLine."Source Code";        DtldCustLedgEntry."Transaction No." := NextTransactionNo;        CustLedgerEntry2.Get(DtldCVLedgEntryBuf."CV Ledger Entry No.");        DtldCustLedgEntry."Posting Group" := CustLedgerEntry2."Customer Posting Group";        DtldCustLedgEntry.UpdateDebitCredit(GenJnlLine.Correction);        OnBeforeInsertDtldCustLedgEntry(DtldCustLedgEntry, GenJnlLine, DtldCVLedgEntryBuf, GLReg);        DtldCustLedgEntry.Insert(true);        OnAfterInsertDtldCustLedgEntry(DtldCustLedgEntry, GenJnlLine, DtldCVLedgEntryBuf, Offset);    end;    local procedure InsertDtldVendLedgEntry(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; Offset: Integer)    var        VendorLedgerEntry2: Record "Vendor Ledger Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertDtldVendLedgEntryProcedure(GenJnlLine, DtldCVLedgEntryBuf, DtldVendLedgEntry, IsHandled);        if IsHandled then            exit;        DtldVendLedgEntry.Init();        DtldVendLedgEntry.TransferFields(DtldCVLedgEntryBuf);        DtldVendLedgEntry."Entry No." := Offset + DtldCVLedgEntryBuf."Entry No.";        DtldVendLedgEntry."Journal Batch Name" := GenJnlLine."Journal Batch Name";        DtldVendLedgEntry."Reason Code" := GenJnlLine."Reason Code";        DtldVendLedgEntry."Source Code" := GenJnlLine."Source Code";        DtldVendLedgEntry."Transaction No." := NextTransactionNo;        VendorLedgerEntry2.Get(DtldCVLedgEntryBuf."CV Ledger Entry No.");        DtldVendLedgEntry."Posting Group" := VendorLedgerEntry2."Vendor Posting Group";        DtldVendLedgEntry.UpdateDebitCredit(GenJnlLine.Correction);        OnBeforeInsertDtldVendLedgEntry(DtldVendLedgEntry, GenJnlLine, DtldCVLedgEntryBuf, GLReg);        DtldVendLedgEntry.Insert(true);        OnAfterInsertDtldVendLedgEntry(DtldVendLedgEntry, GenJnlLine, DtldCVLedgEntryBuf, Offset);    end;    local procedure InsertDtldEmplLedgEntry(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var DtldEmplLedgEntry: Record "Detailed Employee Ledger Entry"; Offset: Integer)    var        EmployeeLedgerEntry2: Record "Employee Ledger Entry";    begin        DtldEmplLedgEntry.Init();        DtldEmplLedgEntry.TransferFields(DtldCVLedgEntryBuf);        DtldEmplLedgEntry."Entry No." := Offset + DtldCVLedgEntryBuf."Entry No.";        DtldEmplLedgEntry."Journal Batch Name" := GenJnlLine."Journal Batch Name";        DtldEmplLedgEntry."Reason Code" := GenJnlLine."Reason Code";        DtldEmplLedgEntry."Source Code" := GenJnlLine."Source Code";        DtldEmplLedgEntry."Transaction No." := NextTransactionNo;        EmployeeLedgerEntry2.Get(DtldCVLedgEntryBuf."CV Ledger Entry No.");        DtldEmplLedgEntry."Posting Group" := EmployeeLedgerEntry2."Employee Posting Group";        DtldEmplLedgEntry.UpdateDebitCredit(GenJnlLine.Correction);        OnBeforeInsertDtldEmplLedgEntry(DtldEmplLedgEntry, GenJnlLine, DtldCVLedgEntryBuf);        DtldEmplLedgEntry.Insert(true);    end;    /// <summary>    /// Prepares and posts customer ledger entries needed for the application. Detailed customer ledger entries are created and posted for both    /// the old and the new customer ledger entry.    /// </summary>    /// <remarks>    /// If the gen. journal line does not allow application or customer/gen. journal line is not setup for application, application is not performed.    /// </remarks>    /// <param name="NewCVLedgEntryBuf">Return value: Buffer to collect customer ledger entries that has been created for the application.</param>    /// <param name="DtldCVLedgEntryBuf">Return value: Buffer to collect detailed customer ledger entries that has been created for the application.</param>    /// <param name="GenJnlLine">Gen. journal line that is being posted.</param>    /// <param name="Cust">Customer that the customer ledger entries are created for.</param>    procedure ApplyCustLedgEntry(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; Cust: Record Customer)    var        OldCustLedgEntry: Record "Cust. Ledger Entry";        OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer";        NewCustLedgEntry: Record "Cust. Ledger Entry";        NewCVLedgEntryBuf2: Record "CV Ledger Entry Buffer";        TempOldCustLedgEntry: Record "Cust. Ledger Entry" temporary;        Completed: Boolean;        AppliedAmount: Decimal;        NewRemainingAmtBeforeAppln: Decimal;        ApplyingDate: Date;        PmtTolAmtToBeApplied: Decimal;        AllApplied: Boolean;        IsAmountToApplyCheckHandled: Boolean;        ShouldUpdateCalcInterest: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeApplyCustLedgEntry(NewCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine, Cust, IsAmountToApplyCheckHandled, IsHandled);        if IsHandled then            exit;        if not IsAmountToApplyCheckHandled then            if NewCVLedgEntryBuf."Amount to Apply" = 0 then                exit;        AllApplied := true;        if (GenJnlLine."Applies-to Doc. No." = '') and (GenJnlLine."Applies-to ID" = '') and           not           ((Cust."Application Method" = Cust."Application Method"::"Apply to Oldest") and            GenJnlLine."Allow Application")        then            exit;        PmtTolAmtToBeApplied := 0;        NewRemainingAmtBeforeAppln := NewCVLedgEntryBuf."Remaining Amount";        NewCVLedgEntryBuf2 := NewCVLedgEntryBuf;        ApplyingDate := GenJnlLine."Posting Date";        OnApplyCustLedgEntryOnBeforePrepareTempCustLedgEntry(GenJnlLine, NewCVLedgEntryBuf, DtldCVLedgEntryBuf, NextEntryNo);        if not PrepareTempCustLedgEntry(GenJnlLine, NewCVLedgEntryBuf, TempOldCustLedgEntry, Cust, ApplyingDate) then            exit;        GenJnlLine."Posting Date" := ApplyingDate;        OnApplyCustLedgEntryOnAfterSetApplyingDate(ApplyingDate);        // Apply the new entry (Payment) to the old entries (Invoices) one at a time        repeat            TempOldCustLedgEntry.CalcFields(              Amount, "Amount (LCY)", "Remaining Amount", "Remaining Amt. (LCY)",              "Original Amount", "Original Amt. (LCY)");            TempOldCustLedgEntry.CopyFilter(Positive, OldCVLedgEntryBuf.Positive);            OnApplyCustLedgEntryOnBeforeCopyFromCustLedgEntry(GenJnlLine, OldCVLedgEntryBuf, TempOldCustLedgEntry, NewCVLedgEntryBuf);            OldCVLedgEntryBuf.CopyFromCustLedgEntry(TempOldCustLedgEntry);            PostApply(              GenJnlLine, DtldCVLedgEntryBuf, OldCVLedgEntryBuf, NewCVLedgEntryBuf, NewCVLedgEntryBuf2,              Cust."Block Payment Tolerance", AllApplied, AppliedAmount, PmtTolAmtToBeApplied);            ShouldUpdateCalcInterest := not OldCVLedgEntryBuf.Open;            OnApplyCustLedgEntryOnAfterCalcShouldUpdateCalcInterestFromOldBuf(OldCVLedgEntryBuf, NewCVLedgEntryBuf, Cust, ShouldUpdateCalcInterest);            if ShouldUpdateCalcInterest then begin                UpdateCalcInterest(OldCVLedgEntryBuf);                UpdateCalcInterest(OldCVLedgEntryBuf, NewCVLedgEntryBuf);            end;            if (OldCVLedgEntryBuf."Currency Code" = NewCVLedgEntryBuf."Currency Code") and (OldCVLedgEntryBuf."Applies-to ID" = '') then                OldCVLedgEntryBuf."Amount to Apply" := 0;            OnApplyCustLedgEntryOnBeforeCopyFromCVLedgEntryBuffer(OldCVLedgEntryBuf, AppliedAmount, GenJnlLine);            TempOldCustLedgEntry.CopyFromCVLedgEntryBuffer(OldCVLedgEntryBuf);            OldCustLedgEntry := TempOldCustLedgEntry;            if GenJnlLine."On Hold" = OldCustLedgEntry."On Hold" then                OldCustLedgEntry."On Hold" := '';            if OldCustLedgEntry."Amount to Apply" = 0 then                OldCustLedgEntry."Applies-to ID" := ''            else begin                TempCustLedgEntry := OldCustLedgEntry;                if TempCustLedgEntry.Insert() then;            end;            OldCustLedgEntry.Modify();            OnAfterOldCustLedgEntryModify(OldCustLedgEntry, GenJnlLine, TempCustLedgEntry, DtldCVLedgEntryBuf);            IsHandled := false;            OnApplyCustLedgEntryOnBeforeCustUnrealizedVAT(TempOldCustLedgEntry, IsHandled, GenJnlLine);            if not IsHandled then                if GLSetup."Unrealized VAT" or                   (GLSetup."Prepayment Unrealized VAT" and TempOldCustLedgEntry.Prepayment)                then                    if IsNotPayment(TempOldCustLedgEntry."Document Type") then begin                        TempOldCustLedgEntry.RecalculateAmounts(                          NewCVLedgEntryBuf."Currency Code", TempOldCustLedgEntry."Currency Code", NewCVLedgEntryBuf."Posting Date");                        OnApplyCustLedgEntryOnAfterRecalculateAmounts(TempOldCustLedgEntry, OldCustLedgEntry, NewCVLedgEntryBuf, GenJnlLine);                        CustUnrealizedVAT(                          GenJnlLine,                          TempOldCustLedgEntry,                          CurrExchRate.ExchangeAmount(                            AppliedAmount, NewCVLedgEntryBuf."Currency Code",                            TempOldCustLedgEntry."Currency Code", NewCVLedgEntryBuf."Posting Date"));                    end;            OnApplyCustLedgEntryOnBeforeTempOldCustLedgEntryDelete(TempOldCustLedgEntry, NewCVLedgEntryBuf, GenJnlLine, Cust, NextEntryNo, GLReg, AppliedAmount, OldCVLedgEntryBuf);            TempOldCustLedgEntry.Delete();            OnApplyCustLedgerEntryOnBeforeSetCompleted(GenJnlLine, OldCustLedgEntry, NewCVLedgEntryBuf, AppliedAmount);            Completed := FindNextOldCustLedgEntryToApply(GenJnlLine, TempOldCustLedgEntry, NewCVLedgEntryBuf);        until Completed;        DtldCVLedgEntryBuf.SetCurrentKey("CV Ledger Entry No.", "Entry Type");        DtldCVLedgEntryBuf.SetRange("CV Ledger Entry No.", NewCVLedgEntryBuf."Entry No.");        DtldCVLedgEntryBuf.SetRange(          "Entry Type",          DtldCVLedgEntryBuf."Entry Type"::Application);        DtldCVLedgEntryBuf.CalcSums("Amount (LCY)", Amount);        CalcCurrencyUnrealizedGainLoss(          NewCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine, DtldCVLedgEntryBuf.Amount, NewRemainingAmtBeforeAppln);        CalcAmtLCYAdjustment(NewCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine);        NewCVLedgEntryBuf."Applies-to ID" := '';        NewCVLedgEntryBuf."Amount to Apply" := 0;        ShouldUpdateCalcInterest := not NewCVLedgEntryBuf.Open;        OnApplyCustLedgEntryOnAfterCalcShouldUpdateCalcInterestFromNewBuf(OldCVLedgEntryBuf, NewCVLedgEntryBuf, Cust, ShouldUpdateCalcInterest);        if ShouldUpdateCalcInterest then            UpdateCalcInterest(NewCVLedgEntryBuf);        IsHandled := false;        OnApplyCustLedgEntryOnBeforeUnrealizedVAT(NewCVLedgEntryBuf, IsHandled, GenJnlLine);        if not IsHandled then            if GLSetup."Unrealized VAT" or               (GLSetup."Prepayment Unrealized VAT" and NewCVLedgEntryBuf.Prepayment)            then                if IsNotPayment(NewCVLedgEntryBuf."Document Type") and                   (NewRemainingAmtBeforeAppln - NewCVLedgEntryBuf."Remaining Amount" <> 0)                then begin                    NewCustLedgEntry.CopyFromCVLedgEntryBuffer(NewCVLedgEntryBuf);                    CheckUnrealizedCust := true;                    UnrealizedCustLedgEntry := NewCustLedgEntry;                    UnrealizedCustLedgEntry.CalcFields("Amount (LCY)", "Original Amt. (LCY)");                    UnrealizedRemainingAmountCust := NewCustLedgEntry."Remaining Amount" - NewRemainingAmtBeforeAppln;                end;        OnAfterApplyCustLedgEntry(GenJnlLine, NewCVLedgEntryBuf, OldCustLedgEntry, NewRemainingAmtBeforeAppln);    end;    local procedure FindNextOldCustLedgEntryToApply(GenJnlLine: Record "Gen. Journal Line"; var TempOldCustLedgEntry: Record "Cust. Ledger Entry" temporary; NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer") Completed: Boolean    var        IsHandled: Boolean;    begin        OnBeforeFindNextOldCustLedgEntryToApply(GenJnlLine, TempOldCustLedgEntry, NewCVLedgEntryBuf, Completed, IsHandled);        if IsHandled then            exit(Completed);        if GenJnlLine."Applies-to Doc. No." <> '' then            Completed := true        else            if TempOldCustLedgEntry.GetFilter(Positive) <> '' then                if TempOldCustLedgEntry.Next() = 1 then                    Completed := false                else begin                    TempOldCustLedgEntry.SetRange(Positive);                    TempOldCustLedgEntry.Find('-');                    TempOldCustLedgEntry.CalcFields("Remaining Amount");                    Completed := TempOldCustLedgEntry."Remaining Amount" * NewCVLedgEntryBuf."Remaining Amount" >= 0;                end            else                if NewCVLedgEntryBuf.Open then                    Completed := TempOldCustLedgEntry.Next() = 0                else                    Completed := true;    end;    /// <summary>    /// Stand-alone procedure to post (from check to finish) application gen. journal line for the customer ledger entries.    /// G/l entries, vat entries, customer ledger entries and detailed customer ledger entries are created and posted.    /// </summary>    /// <param name="GenJnlLinePostApply">Gen. journal line that should be posted for application purpose.</param>    /// <param name="CustLedgEntryPostApply">Customer ledger entry that the new application should be applied to.</param>    procedure CustPostApplyCustLedgEntry(var GenJnlLinePostApply: Record "Gen. Journal Line"; var CustLedgEntryPostApply: Record "Cust. Ledger Entry")    var        Cust: Record Customer;        CustPostingGr: Record "Customer Posting Group";        CustLedgEntry: Record "Cust. Ledger Entry";        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary;        CVLedgEntryBuf: Record "CV Ledger Entry Buffer";        GenJnlLine: Record "Gen. Journal Line";        DtldLedgEntryInserted: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCustPostApplyCustLedgEntry(GenJnlLinePostApply, CustLedgEntryPostApply, IsHandled);        if IsHandled then            exit;        GenJnlLine := GenJnlLinePostApply;        CustLedgEntry.TransferFields(CustLedgEntryPostApply);        OnCustPostApplyCustLedgEntryOnAfterCustLedgEntryTransferFields(CustLedgEntry, GenJnlLine);        GenJnlLine."Source Currency Code" := CustLedgEntryPostApply."Currency Code";        GenJnlLine."Applies-to ID" := CustLedgEntryPostApply."Applies-to ID";        AmountRoundingPrecision := GetSourceCurrency(GenJnlLine."Source Currency Code");        IsHandled := false;        OnCustPostApplyCustLedgEntryOnBeforeRunCheck(GenJnlLine, CustLedgEntryPostApply, CustLedgEntry, IsHandled);        if not IsHandled then            GenJnlCheckLine.RunCheck(GenJnlLine);        if NextEntryNo = 0 then            StartPosting(GenJnlLine)        else            ContinuePosting(GenJnlLine);        Cust.Get(CustLedgEntry."Customer No.");        Cust.CheckBlockedCustOnJnls(Cust, GenJnlLine."Document Type", true);        OnCustPostApplyCustLedgEntryOnBeforeCheckPostingGroup(GenJnlLine, Cust);        if GenJnlLine."Posting Group" = '' then begin            Cust.TestField("Customer Posting Group");            GenJnlLine."Posting Group" := Cust."Customer Posting Group";        end;        CustPostingGr.Get(GenJnlLine."Posting Group");        GetCustomerReceivablesAccount(GenJnlLine, CustPostingGr);        DtldCustLedgEntry.LockTable();        CustLedgEntry.LockTable();        // Post the application        CustLedgEntry.CalcFields(          Amount, "Amount (LCY)", "Remaining Amount", "Remaining Amt. (LCY)",          "Original Amount", "Original Amt. (LCY)");        OnCustPostApplyCustLedgEntryOnBeforeCopyFromCustLedgEntry(GenJnlLine, CVLedgEntryBuf, CustLedgEntry);        CVLedgEntryBuf.CopyFromCustLedgEntry(CustLedgEntry);        OnCustPostApplyCustLedgEntryOnBeforeApplyCustLedgEntry(CustLedgEntry, GenJnlLine, CVLedgEntryBuf);        ApplyCustLedgEntry(CVLedgEntryBuf, TempDtldCVLedgEntryBuf, GenJnlLine, Cust);        OnCustPostApplyCustLedgEntryOnAfterApplyCustLedgEntry(GenJnlLine, TempDtldCVLedgEntryBuf);        CustLedgEntry.CopyFromCVLedgEntryBuffer(CVLedgEntryBuf);        OnCustPostApplyCustLedgEntryOnBeforeModifyCustLedgEntry(CustLedgEntry, CVLedgEntryBuf);        CustLedgEntry.Modify();        // Post the Dtld customer entry        OnCustPostApplyCustLedgEntryOnBeforePostDtldCustLedgEntries(CustLedgEntry);        DtldLedgEntryInserted := PostDtldCustLedgEntries(GenJnlLine, TempDtldCVLedgEntryBuf, CustPostingGr, false);        OnCustPostApplyCustLedgEntryOnBeforeCheckPostUnrealizedVAT(GenJnlLine, TempDtldCVLedgEntryBuf, DtldLedgEntryInserted);        CheckPostUnrealizedVAT(GenJnlLine, true);        if DtldLedgEntryInserted then            if IsTempGLEntryBufEmpty() then                DtldCustLedgEntry.SetZeroTransNo(NextTransactionNo);        OnCustPostApplyCustLedgEntryOnBeforeFinishPosting(GenJnlLine, CustLedgEntry);        FinishPosting(GenJnlLine);        OnAfterCustPostApplyCustLedgEntry(GenJnlLine, GLReg, CustLedgEntry);    end;    local procedure PrepareTempCustLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var TempOldCustLedgEntry: Record "Cust. Ledger Entry" temporary; Cust: Record Customer; var ApplyingDate: Date): Boolean    var        OldCustLedgEntry: Record "Cust. Ledger Entry";        SalesSetup: Record "Sales & Receivables Setup";        GenJnlApply: Codeunit "Gen. Jnl.-Apply";        RemainingAmount: Decimal;        IsHandled: Boolean;        Result: Boolean;        SufficientEntriesFound: Boolean;        NextStep: Integer;    begin        IsHandled := false;        OnBeforePrepareTempCustledgEntry(GenJnlLine, NewCVLedgEntryBuf, Cust, ApplyingDate, Result, IsHandled, TempOldCustLedgEntry);        if IsHandled then            exit(Result);        if GenJnlLine."Applies-to Doc. No." <> '' then begin            // Find the entry to be applied to            OldCustLedgEntry.Reset();            OldCustLedgEntry.SetLoadFields(Positive, "Posting Date", "Currency Code");            OldCustLedgEntry.SetCurrentKey("Document No.");            OldCustLedgEntry.SetRange("Document No.", GenJnlLine."Applies-to Doc. No.");            OldCustLedgEntry.SetRange("Document Type", GenJnlLine."Applies-to Doc. Type");            OldCustLedgEntry.SetRange("Customer No.", NewCVLedgEntryBuf."CV No.");            OldCustLedgEntry.SetRange(Open, true);            OnPrepareTempCustLedgEntryOnAfterSetFilters(OldCustLedgEntry, GenJnlLine, NewCVLedgEntryBuf, NextEntryNo);            OldCustLedgEntry.FindFirst();            OnPrepareTempCustLedgEntryOnBeforeTestPositive(GenJnlLine, IsHandled);            if not IsHandled then                if not ((GenJnlLine.Amount < 0) and                        (GenJnlLine."Document Type" = GenJnlLine."Document Type"::" ") and                        (GenJnlLine."Account Type" = GenJnlLine."Account Type"::Customer) and                        (GenJnlLine."Applies-to Doc. Type" = GenJnlLine."Applies-to Doc. Type"::"Finance Charge Memo") and                        (GenJnlLine."Applies-to Doc. No." <> '')) then                    OldCustLedgEntry.TestField(Positive, not NewCVLedgEntryBuf.Positive);            if OldCustLedgEntry."Posting Date" > ApplyingDate then                ApplyingDate := OldCustLedgEntry."Posting Date";            OnPrepareTempCustLedgEntryOnBeforeCheckAgainstApplnCurrencyWithAppliesToDocNo(GenJnlLine, NewCVLedgEntryBuf, OldCustLedgEntry);            GenJnlApply.CheckAgainstApplnCurrency(              NewCVLedgEntryBuf."Currency Code", OldCustLedgEntry."Currency Code", GenJnlLine."Account Type"::Customer, true);            TempOldCustLedgEntry := OldCustLedgEntry;            OnPrepareTempCustLedgEntryOnBeforeTempOldCustLedgEntryInsert(TempOldCustLedgEntry, GenJnlLine);            TempOldCustLedgEntry.Insert();        end else begin            // Find the first old entry (Invoice) which the new entry (Payment) should apply to            OldCustLedgEntry.Reset();            OldCustLedgEntry.SetLoadFields("Posting Date", "Currency Code", "Applies-to ID");            OldCustLedgEntry.SetCurrentKey("Customer No.", "Applies-to ID", Open, Positive, "Due Date");            TempOldCustLedgEntry.SetCurrentKey("Customer No.", "Applies-to ID", Open, Positive, "Due Date");            OldCustLedgEntry.SetRange("Customer No.", NewCVLedgEntryBuf."CV No.");            OldCustLedgEntry.SetRange("Applies-to ID", GenJnlLine."Applies-to ID");            OldCustLedgEntry.SetRange(Open, true);            OldCustLedgEntry.SetFilter("Entry No.", '<>%1', NewCVLedgEntryBuf."Entry No.");            if not (Cust."Application Method" = Cust."Application Method"::"Apply to Oldest") then                OldCustLedgEntry.SetFilter("Amount to Apply", '<>%1', 0);            if Cust."Application Method" = Cust."Application Method"::"Apply to Oldest" then                OldCustLedgEntry.SetFilter("Posting Date", '..%1', GenJnlLine."Posting Date");            // Check Cust Ledger Entry and add to Temp.            SalesSetup.Get();            if SalesSetup."Appln. between Currencies" = SalesSetup."Appln. between Currencies"::None then                OldCustLedgEntry.SetRange("Currency Code", NewCVLedgEntryBuf."Currency Code");            OnPrepareTempCustLedgEntryOnAfterSetFiltersByAppliesToId(OldCustLedgEntry, GenJnlLine, NewCVLedgEntryBuf, Cust);            if OldCustLedgEntry.FindSet(false) then                repeat                    OnPrepareTempCustLedgEntryOnBeforeCheckAgainstApplnCurrency(GenJnlLine, NewCVLedgEntryBuf, OldCustLedgEntry);                    if GenJnlApply.CheckAgainstApplnCurrency(                         NewCVLedgEntryBuf."Currency Code", OldCustLedgEntry."Currency Code", GenJnlLine."Account Type"::Customer, false)                    then begin                        if (OldCustLedgEntry."Posting Date" > ApplyingDate) and (OldCustLedgEntry."Applies-to ID" <> '') then                            ApplyingDate := OldCustLedgEntry."Posting Date";                        TempOldCustLedgEntry := OldCustLedgEntry;                        OnPrepareTempCustLedgEntryOnBeforeTempOldCustLedgEntryInsert(TempOldCustLedgEntry, GenJnlLine);                        TempOldCustLedgEntry.Insert();                    end;                until OldCustLedgEntry.Next() = 0;            TempOldCustLedgEntry.SetRange(Positive, NewCVLedgEntryBuf."Remaining Amount" > 0);            if TempOldCustLedgEntry.Find('-') then begin                RemainingAmount := NewCVLedgEntryBuf."Remaining Amount";                TempOldCustLedgEntry.SetRange(Positive);                // Weigh the entries of the same sign as the new document before the opposite-sign ones.                // The sign decision below is a property of the whole open-entry set, so the early exit                // must not stop before the opposite-sign entries have settled that sign.                if NewCVLedgEntryBuf."Remaining Amount" > 0 then begin                    TempOldCustLedgEntry.Find('+');                    NextStep := -1;                end else begin                    TempOldCustLedgEntry.Find('-');                    NextStep := 1;                end;                repeat                    TempOldCustLedgEntry.CalcFields("Remaining Amount");                    TempOldCustLedgEntry.RecalculateAmounts(                      TempOldCustLedgEntry."Currency Code", NewCVLedgEntryBuf."Currency Code", NewCVLedgEntryBuf."Posting Date");                    if PaymentToleranceMgt.CheckCalcPmtDiscCVCust(NewCVLedgEntryBuf, TempOldCustLedgEntry, 0, false, false) then                        TempOldCustLedgEntry."Remaining Amount" -= TempOldCustLedgEntry.GetRemainingPmtDiscPossible(NewCVLedgEntryBuf."Posting Date");                    RemainingAmount += TempOldCustLedgEntry."Remaining Amount";                    if (Cust."Application Method" = Cust."Application Method"::"Apply to Oldest") and                       (RemainingAmount * NewCVLedgEntryBuf."Remaining Amount" < 0)                    then                        SufficientEntriesFound := true;                until (TempOldCustLedgEntry.Next(NextStep) = 0) or SufficientEntriesFound;                TempOldCustLedgEntry.SetRange(Positive, RemainingAmount < 0);            end else                TempOldCustLedgEntry.SetRange(Positive);            OnPrepareTempCustLedgEntryOnBeforeExit(GenJnlLine, NewCVLedgEntryBuf, TempOldCustLedgEntry);            exit(TempOldCustLedgEntry.Find('-'));        end;        exit(true);    end;    /// <summary>    /// Posts all detailed customer ledger entries that are stored in DtldCVLedgEntryBuf. Creates g/l entry for the total amounts.    /// </summary>    /// <remarks>    /// DtldCVLedgEntryBuf is cleared after the procedure is finished.    /// </remarks>    /// <param name="GenJnlLine">Gen. journal line that is being posted.</param>    /// <param name="DtldCVLedgEntryBuf">Detailed customer ledger entries to be inserted and posted.</param>    /// <param name="CustPostingGr">Customer posting group to be used for detailed cust. ledger entries.</param>    /// <param name="LedgEntryInserted">Flag if customer ledger entries have already been created in the same transaction.</param>    /// <returns>True if any detailed customer ledger entries has been created.</returns>    procedure PostDtldCustLedgEntries(GenJnlLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; CustPostingGr: Record "Customer Posting Group"; LedgEntryInserted: Boolean) DtldLedgEntryInserted: Boolean    var        TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary;        DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        AdjAmount: array[4] of Decimal;        DtldCustLedgEntryNoOffset: Integer;        SaveEntryNo: Integer;        IsHandled: Boolean;    begin        OnBeforePostDtldCustLedgEntries(GenJnlLine, DtldCVLedgEntryBuf, CustPostingGr, LedgEntryInserted);        if GenJnlLine."Account Type" <> GenJnlLine."Account Type"::Customer then            exit;        if DtldCustLedgEntry.FindLast() then            DtldCustLedgEntryNoOffset := DtldCustLedgEntry."Entry No."        else            DtldCustLedgEntryNoOffset := 0;        OnPostDtldCustLedgEntriesOnAfterSetDtldCustLedgEntryNoOffset(GenJnlLine, DtldCVLedgEntryBuf, CustPostingGr, LedgEntryInserted, NextEntryNo);        MultiplePostingGroups := CheckCustMultiplePostingGroups(DtldCVLedgEntryBuf);        DtldCVLedgEntryBuf.Reset();        OnAfterSetDtldCustLedgEntryNoOffset(DtldCVLedgEntryBuf, DtldCustLedgEntryNoOffset);        if DtldCVLedgEntryBuf.FindSet() then begin            IsHandled := false;            OnPostDtldCustLedgEntriesOnBeforeNextEntryNo(GenJnlLine, DtldCVLedgEntryBuf, CustPostingGr, LedgEntryInserted, NextEntryNo, SaveEntryNo, IsHandled);            if not IsHandled then                if LedgEntryInserted then begin                    SaveEntryNo := NextEntryNo;                    IncrNextEntryNo();                end;            repeat                InsertDtldCustLedgEntry(GenJnlLine, DtldCVLedgEntryBuf, DtldCustLedgEntry, DtldCustLedgEntryNoOffset);                IsHandled := false;                OnPostDtldCustLedgEntriesOnBeforeUpdateTotalAmounts(GenJnlLine, DtldCustLedgEntry, IsHandled, DtldCVLedgEntryBuf);                if not IsHandled then                    UpdateTotalAmounts(TempDimPostingBuffer, GenJnlLine."Dimension Set ID", DtldCVLedgEntryBuf);                IsHandled := false;                OnPostDtldCustLedgEntriesOnBeforePostDtldCustLedgEntry(DtldCVLedgEntryBuf, AddCurrencyCode, GenJnlLine, CustPostingGr, AdjAmount, IsHandled, NextEntryNo, DtldCustLedgEntry, LedgEntryInserted);                if not IsHandled then                    if ((DtldCVLedgEntryBuf."Amount (LCY)" <> 0) or                        (DtldCVLedgEntryBuf."VAT Amount (LCY)" <> 0)) or                       ((AddCurrencyCode <> '') and (DtldCVLedgEntryBuf."Additional-Currency Amount" <> 0))                    then                        PostDtldCustLedgEntry(GenJnlLine, DtldCVLedgEntryBuf, CustPostingGr, AdjAmount);            until DtldCVLedgEntryBuf.Next() = 0;        end;        IsHandled := false;        OnPostDtldCustLedgEntriesOnBeforeCreateGLEntriesForTotalAmountsV19(            CustPostingGr, DtldCVLedgEntryBuf,            GenJnlLine, TempDimPostingBuffer, AdjAmount, SaveEntryNo, GetCustomerReceivablesAccount(GenJnlLine, CustPostingGr), LedgEntryInserted, AddCurrencyCode, IsHandled);        if not IsHandled then            CreateGLEntriesForTotalAmounts(              GenJnlLine, TempDimPostingBuffer, AdjAmount, SaveEntryNo, GetCustomerReceivablesAccount(GenJnlLine, CustPostingGr), LedgEntryInserted);        OnPostDtldCustLedgEntriesOnAfterCreateGLEntriesForTotalAmounts(TempGLEntryBuf, GlobalGLEntry, NextTransactionNo);        DtldLedgEntryInserted := not DtldCVLedgEntryBuf.IsEmpty();        DtldCVLedgEntryBuf.DeleteAll();    end;    local procedure PostDtldCustLedgEntry(GenJournalLine: Record "Gen. Journal Line"; DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; CustPostingGr: Record "Customer Posting Group"; var AdjAmount: array[4] of Decimal)    var        AccNo: Code[20];    begin        if MultiplePostingGroups and (DetailedCVLedgEntryBuffer."Entry Type" = DetailedCVLedgEntryBuffer."Entry Type"::Application) then            AccNo := GetCustDtldCVLedgEntryBufferAccNo(GenJournalLine, DetailedCVLedgEntryBuffer)        else            AccNo := GetDtldCustLedgEntryAccNo(GenJournalLine, DetailedCVLedgEntryBuffer, CustPostingGr, 0, false);        PostDtldCVLedgEntry(GenJournalLine, DetailedCVLedgEntryBuffer, AccNo, AdjAmount, false);    end;    local procedure PostDtldCustLedgEntryUnapply(GenJournalLine: Record "Gen. Journal Line"; DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; CustPostingGr: Record "Customer Posting Group"; OriginalTransactionNo: Integer)    var        AdjAmount: array[4] of Decimal;        AccNo: Code[20];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostDtldCustLedgEntryUnapply(GenJournalLine, DetailedCVLedgEntryBuffer, CustPostingGr, OriginalTransactionNo, IsHandled);        if IsHandled then            exit;        if (DetailedCVLedgEntryBuffer."Amount (LCY)" = 0) and           (DetailedCVLedgEntryBuffer."VAT Amount (LCY)" = 0) and           ((AddCurrencyCode = '') or (DetailedCVLedgEntryBuffer."Additional-Currency Amount" = 0))        then            exit;        if MultiplePostingGroups and (DetailedCVLedgEntryBuffer."Entry Type" = DetailedCVLedgEntryBuffer."Entry Type"::Application) then            AccNo := GetCustDtldCVLedgEntryBufferAccNo(GenJournalLine, DetailedCVLedgEntryBuffer)        else            AccNo := GetDtldCustLedgEntryAccNo(GenJournalLine, DetailedCVLedgEntryBuffer, CustPostingGr, OriginalTransactionNo, true);        DetailedCVLedgEntryBuffer."Gen. Posting Type" := DetailedCVLedgEntryBuffer."Gen. Posting Type"::Sale;        PostDtldCVLedgEntry(GenJournalLine, DetailedCVLedgEntryBuffer, AccNo, AdjAmount, true);    end;    local procedure GetDtldCustLedgEntryAccNo(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; CustPostingGr: Record "Customer Posting Group"; OriginalTransactionNo: Integer; Unapply: Boolean) AccountNo: Code[20]    var        GenPostingSetup: Record "General Posting Setup";        Currency: Record Currency;        AmountCondition: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetDtldCustLedgEntryAccNo(GenJnlLine, DtldCVLedgEntryBuf, CustPostingGr, OriginalTransactionNo, Unapply, VATEntry, AccountNo, IsHandled);        if IsHandled then            exit(AccountNo);        AmountCondition := IsDebitAmount(DtldCVLedgEntryBuf, Unapply);        case DtldCVLedgEntryBuf."Entry Type" of            DtldCVLedgEntryBuf."Entry Type"::"Initial Entry":                ;            DtldCVLedgEntryBuf."Entry Type"::Application:                ;            DtldCVLedgEntryBuf."Entry Type"::"Unrealized Loss",            DtldCVLedgEntryBuf."Entry Type"::"Unrealized Gain",            DtldCVLedgEntryBuf."Entry Type"::"Realized Loss",            DtldCVLedgEntryBuf."Entry Type"::"Realized Gain":                begin                    GetCurrency(Currency, DtldCVLedgEntryBuf."Currency Code");                    CheckNonAddCurrCodeOccurred(Currency.Code);                    exit(Currency.GetGainLossAccount(DtldCVLedgEntryBuf));                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount":                exit(CustPostingGr.GetPmtDiscountAccount(AmountCondition));            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Excl.)":                begin                    DtldCVLedgEntryBuf.TestField("Gen. Prod. Posting Group");                    GenPostingSetup.Get(DtldCVLedgEntryBuf."Gen. Bus. Posting Group", DtldCVLedgEntryBuf."Gen. Prod. Posting Group");                    exit(GenPostingSetup.GetSalesPmtDiscountAccount(AmountCondition));                end;            DtldCVLedgEntryBuf."Entry Type"::"Appln. Rounding":                exit(CustPostingGr.GetApplRoundingAccount(AmountCondition));            DtldCVLedgEntryBuf."Entry Type"::"Correction of Remaining Amount":                exit(CustPostingGr.GetRoundingAccount(AmountCondition));            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance":                case GLSetup."Pmt. Disc. Tolerance Posting" of                    GLSetup."Pmt. Disc. Tolerance Posting"::"Payment Tolerance Accounts":                        exit(CustPostingGr.GetPmtToleranceAccount(AmountCondition));                    GLSetup."Pmt. Disc. Tolerance Posting"::"Payment Discount Accounts":                        exit(CustPostingGr.GetPmtDiscountAccount(AmountCondition));                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance":                case GLSetup."Payment Tolerance Posting" of                    GLSetup."Payment Tolerance Posting"::"Payment Tolerance Accounts":                        exit(CustPostingGr.GetPmtToleranceAccount(AmountCondition));                    GLSetup."Payment Tolerance Posting"::"Payment Discount Accounts":                        exit(CustPostingGr.GetPmtDiscountAccount(AmountCondition));                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Excl.)":                begin                    DtldCVLedgEntryBuf.TestField("Gen. Prod. Posting Group");                    GenPostingSetup.Get(DtldCVLedgEntryBuf."Gen. Bus. Posting Group", DtldCVLedgEntryBuf."Gen. Prod. Posting Group");                    case GLSetup."Payment Tolerance Posting" of                        GLSetup."Payment Tolerance Posting"::"Payment Tolerance Accounts":                            exit(GenPostingSetup.GetSalesPmtToleranceAccount(AmountCondition));                        GLSetup."Payment Tolerance Posting"::"Payment Discount Accounts":                            exit(GenPostingSetup.GetSalesPmtDiscountAccount(AmountCondition));                    end;                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Excl.)":                begin                    GenPostingSetup.Get(DtldCVLedgEntryBuf."Gen. Bus. Posting Group", DtldCVLedgEntryBuf."Gen. Prod. Posting Group");                    case GLSetup."Pmt. Disc. Tolerance Posting" of                        GLSetup."Pmt. Disc. Tolerance Posting"::"Payment Tolerance Accounts":                            exit(GenPostingSetup.GetSalesPmtToleranceAccount(AmountCondition));                        GLSetup."Pmt. Disc. Tolerance Posting"::"Payment Discount Accounts":                            exit(GenPostingSetup.GetSalesPmtDiscountAccount(AmountCondition));                    end;                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Adjustment)",          DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Adjustment)",          DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Adjustment)":                if Unapply then                    PostDtldCustVATAdjustment(GenJnlLine, DtldCVLedgEntryBuf, OriginalTransactionNo);            else                DtldCVLedgEntryBuf.FieldError("Entry Type");        end;    end;    internal procedure CustUnrealizedVAT(GenJnlLine: Record "Gen. Journal Line"; var CustLedgEntry2: Record "Cust. Ledger Entry"; SettledAmount: Decimal)    var        VATEntry2: Record "VAT Entry";        TaxJurisdiction: Record "Tax Jurisdiction";        VATPostingSetup: Record "VAT Posting Setup";        VATPart: Decimal;        VATAmount: Decimal;        VATBase: Decimal;        VATAmountAddCurr: Decimal;        VATBaseAddCurr: Decimal;        PaidAmount: Decimal;        TotalUnrealVATAmountLast: Decimal;        TotalUnrealVATAmountFirst: Decimal;        SalesVATAccount: Code[20];        SalesVATUnrealAccount: Code[20];        LastConnectionNo: Integer;        GLEntryNo: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCustUnrealizedVAT(GenJnlLine, CustLedgEntry2, SettledAmount, IsHandled);        if IsHandled then            exit;        PaidAmount := CustLedgEntry2."Amount (LCY)" - CustLedgEntry2."Remaining Amt. (LCY)";        OnCustUnrealizedVATOnAfterCalcPaidAmount(GenJnlLine, CustLedgEntry2, SettledAmount, PaidAmount);        VATEntry2.ReadIsolation := IsolationLevel::ReadUncommitted;        VATEntry2.Reset();        VATEntry2.SetCurrentKey("Transaction No.");        VATEntry2.SetRange("Transaction No.", CustLedgEntry2."Transaction No.");        OnCustUnrealizedVATOnAfterSetFilterForVATEntry2(VATEntry2);        if VATEntry2.FindSet() then            repeat                VATPostingSetup.Get(VATEntry2."VAT Bus. Posting Group", VATEntry2."VAT Prod. Posting Group");                if VATPostingSetup."Unrealized VAT Type" in                   [VATPostingSetup."Unrealized VAT Type"::Last, VATPostingSetup."Unrealized VAT Type"::"Last (Fully Paid)"]                then                    TotalUnrealVATAmountLast := TotalUnrealVATAmountLast - VATEntry2."Remaining Unrealized Amount";                if VATPostingSetup."Unrealized VAT Type" in                   [VATPostingSetup."Unrealized VAT Type"::First, VATPostingSetup."Unrealized VAT Type"::"First (Fully Paid)"]                then                    TotalUnrealVATAmountFirst := TotalUnrealVATAmountFirst - VATEntry2."Remaining Unrealized Amount";            until VATEntry2.Next() = 0;        if VATEntry2.FindSet() then begin            LastConnectionNo := 0;            repeat                VATPostingSetup.Get(VATEntry2."VAT Bus. Posting Group", VATEntry2."VAT Prod. Posting Group");                if LastConnectionNo <> VATEntry2."Sales Tax Connection No." then begin                    InsertSummarizedVAT(GenJnlLine);                    LastConnectionNo := VATEntry2."Sales Tax Connection No.";                end;                IsHandled := false;                OnCustUnrealizedVATOnBeforeGetUnrealizedVATPart(GenJnlLine, CustLedgEntry2, PaidAmount, TotalUnrealVATAmountFirst, TotalUnrealVATAmountLast, SettledAmount, VATEntry2, VATPart, IsHandled);                if not IsHandled then                    VATPart :=                      VATEntry2.GetUnrealizedVATPart(                        Round(SettledAmount / CustLedgEntry2.GetAdjustedCurrencyFactor()),                        PaidAmount,                        CustLedgEntry2."Amount (LCY)",                        TotalUnrealVATAmountFirst,                        TotalUnrealVATAmountLast);                OnCustUnrealizedVATOnAfterVATPartCalculation(                  GenJnlLine, CustLedgEntry2, PaidAmount, TotalUnrealVATAmountFirst, TotalUnrealVATAmountLast, SettledAmount, VATEntry2);                if VATPart > 0 then begin                    case VATEntry2."VAT Calculation Type" of                        VATEntry2."VAT Calculation Type"::"Normal VAT",                        VATEntry2."VAT Calculation Type"::"Reverse Charge VAT",                        VATEntry2."VAT Calculation Type"::"Full VAT":                            begin                                SalesVATAccount := VATPostingSetup.GetSalesAccount(false);                                SalesVATUnrealAccount := VATPostingSetup.GetSalesAccount(true);                            end;                        VATEntry2."VAT Calculation Type"::"Sales Tax":                            begin                                TaxJurisdiction.Get(VATEntry2."Tax Jurisdiction Code");                                SalesVATAccount := TaxJurisdiction.GetSalesAccount(false);                                SalesVATUnrealAccount := TaxJurisdiction.GetSalesAccount(true);                            end;                    end;                    OnCustUnrealizedVATOnAfterSetSalesVATAccounts(VATEntry2, VATPostingSetup, SalesVATAccount, SalesVATUnrealAccount);                    if VATPart = 1 then begin                        VATAmount := VATEntry2."Remaining Unrealized Amount";                        VATBase := VATEntry2."Remaining Unrealized Base";                        VATAmountAddCurr := VATEntry2."Add.-Curr. Rem. Unreal. Amount";                        VATBaseAddCurr := VATEntry2."Add.-Curr. Rem. Unreal. Base";                    end else begin                        VATAmount := Round(VATEntry2."Remaining Unrealized Amount" * VATPart, GLSetup."Amount Rounding Precision");                        VATBase := Round(VATEntry2."Remaining Unrealized Base" * VATPart, GLSetup."Amount Rounding Precision");                        VATAmountAddCurr :=                          Round(                            VATEntry2."Add.-Curr. Rem. Unreal. Amount" * VATPart,                            AddCurrency."Amount Rounding Precision");                        VATBaseAddCurr :=                          Round(                            VATEntry2."Add.-Curr. Rem. Unreal. Base" * VATPart,                            AddCurrency."Amount Rounding Precision");                    end;                    IsHandled := false;                    OnCustUnrealizedVATOnBeforeInitGLEntryVAT(                      GenJnlLine, VATEntry2, VATAmount, VATBase, VATAmountAddCurr, VATBaseAddCurr, IsHandled, SalesVATUnrealAccount, CustLedgEntry2, SettledAmount);                    if not IsHandled then                        InitGLEntryVAT(                            GenJnlLine, SalesVATUnrealAccount, SalesVATAccount, -VATAmount, -VATAmountAddCurr, false);                    GLEntryNo :=                      InitGLEntryVATCopy(GenJnlLine, SalesVATAccount, SalesVATUnrealAccount, VATAmount, VATAmountAddCurr, VATEntry2);                    OnCustUnrealizedVATOnBeforePostUnrealVATEntry(GenJnlLine, VATEntry2, VATAmount, VATBase, VATAmountAddCurr, VATBaseAddCurr, GLEntryNo, VATPart);                    PostUnrealVATEntry(GenJnlLine, VATEntry2, VATAmount, VATBase, VATAmountAddCurr, VATBaseAddCurr, GLEntryNo);                end;            until VATEntry2.Next() = 0;            InsertSummarizedVAT(GenJnlLine);        end;    end;    /// <summary>    /// Prepares and posts vendor ledger entries needed for the application. Detailed vendor ledger entries are created and posted for both    /// the old and the new vendor ledger entry.    /// </summary>    /// <param name="NewCVLedgEntryBuf">Return value: Buffer to collect vendor ledger entries that has been created for the application.</param>    /// <param name="DtldCVLedgEntryBuf">Return value: Buffer to collect detailed vendor ledger entries that has been created for the application.</param>    /// <param name="GenJnlLine">Gen. journal line that is being posted.</param>    /// <param name="Vend">Vendor that the vendor ledger entries are created for.</param>    procedure ApplyVendLedgEntry(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; Vend: Record Vendor)    var        OldVendLedgEntry: Record "Vendor Ledger Entry";        OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer";        NewVendLedgEntry: Record "Vendor Ledger Entry";        NewCVLedgEntryBuf2: Record "CV Ledger Entry Buffer";        TempOldVendLedgEntry: Record "Vendor Ledger Entry" temporary;        Completed: Boolean;        AppliedAmount: Decimal;        NewRemainingAmtBeforeAppln: Decimal;        ApplyingDate: Date;        PmtTolAmtToBeApplied: Decimal;        RemainingTaxAmount: Decimal;        AllApplied: Boolean;        IsAmountToApplyCheckHandled: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeApplyVendLedgEntry(NewCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine, Vend, IsAmountToApplyCheckHandled, IsHandled);        if IsHandled then            exit;        if not IsAmountToApplyCheckHandled then            if NewCVLedgEntryBuf."Amount to Apply" = 0 then                exit;        AllApplied := true;        if (GenJnlLine."Applies-to Doc. No." = '') and (GenJnlLine."Applies-to ID" = '') and           not           ((Vend."Application Method" = Vend."Application Method"::"Apply to Oldest") and            GenJnlLine."Allow Application")        then            exit;        PmtTolAmtToBeApplied := 0;        NewRemainingAmtBeforeAppln := NewCVLedgEntryBuf."Remaining Amount";        NewCVLedgEntryBuf2 := NewCVLedgEntryBuf;        ApplyingDate := GenJnlLine."Posting Date";        if not PrepareTempVendLedgEntry(GenJnlLine, NewCVLedgEntryBuf, TempOldVendLedgEntry, Vend, ApplyingDate) then            exit;        GenJnlLine."Posting Date" := ApplyingDate;        // Apply the new entry (Payment) to the old entries (Invoices) one at a time        repeat            TempOldVendLedgEntry.CalcFields(              Amount, "Amount (LCY)", "Remaining Amount", "Remaining Amt. (LCY)",              "Original Amount", "Original Amt. (LCY)");            OnApplyVendLedgEntryOnBeforeCopyFromVendLedgEntry(GenJnlLine, OldCVLedgEntryBuf, TempOldVendLedgEntry, NewCVLedgEntryBuf);            OldCVLedgEntryBuf.CopyFromVendLedgEntry(TempOldVendLedgEntry);            TempOldVendLedgEntry.CopyFilter(Positive, OldCVLedgEntryBuf.Positive);            PostApply(              GenJnlLine, DtldCVLedgEntryBuf, OldCVLedgEntryBuf, NewCVLedgEntryBuf, NewCVLedgEntryBuf2,              Vend."Block Payment Tolerance", AllApplied, AppliedAmount, PmtTolAmtToBeApplied);            // Update the Old Entry            OnBeforeCopyFromCVLedgEntryBuffer(GenJnlLine, OldVendLedgEntry, TempOldVendLedgEntry, OldCVLedgEntryBuf, NewCVLedgEntryBuf, AppliedAmount, RemainingTaxAmount, NextTransactionNo, NextTaxEntryNo);            TempOldVendLedgEntry.CopyFromCVLedgEntryBuffer(OldCVLedgEntryBuf);            OldVendLedgEntry := TempOldVendLedgEntry;            if GenJnlLine."On Hold" = OldVendLedgEntry."On Hold" then                OldVendLedgEntry."On Hold" := '';            IsHandled := false;            OnBeforeUpdateOldVendLedgEntryAmountToApply(GenJnlLine, OldVendLedgEntry, OldCVLedgEntryBuf, RemainingTaxAmount, AppliedAmount, IsHandled);            if not IsHandled then begin                OldVendLedgEntry."Amount to Apply" := OldCVLedgEntryBuf."Amount to Apply";                if OldVendLedgEntry."Amount to Apply" = 0 then                    OldVendLedgEntry."Applies-to ID" := ''                else begin                    TempVendorLedgerEntry := OldVendLedgEntry;                    if TempVendorLedgerEntry.Insert() then;                end;            end;            OnApplyVendLedgEntryOnBeforeOldVendLedgEntryModify(GenJnlLine, OldVendLedgEntry, NewCVLedgEntryBuf, AppliedAmount);            OldVendLedgEntry.Modify();            OnAfterOldVendLedgEntryModify(OldVendLedgEntry, GenJnlLine, TempVendorLedgerEntry, DtldCVLedgEntryBuf, AppliedAmount, NextTaxEntryNo, NextEntryNo, NextCheckEntryNo, NextTransactionNo);            IsHandled := false;            OnApplyVendLedgEntryOnBeforeVendUnrealizedVAT(TempOldVendLedgEntry, IsHandled, GenJnlLine);            if not IsHandled then                if GLSetup."Unrealized VAT" or                   (GLSetup."Prepayment Unrealized VAT" and TempOldVendLedgEntry.Prepayment)                then                    if IsNotPayment(TempOldVendLedgEntry."Document Type") then begin                        TempOldVendLedgEntry.RecalculateAmounts(                          NewCVLedgEntryBuf."Currency Code", TempOldVendLedgEntry."Currency Code", NewCVLedgEntryBuf."Posting Date");                        OnApplyVendLedgEntryOnAfterRecalculateAmounts(TempOldVendLedgEntry, OldVendLedgEntry, NewCVLedgEntryBuf, GenJnlLine);                        VendUnrealizedVAT(                          GenJnlLine,                          TempOldVendLedgEntry,                          CurrExchRate.ExchangeAmount(                            AppliedAmount, NewCVLedgEntryBuf."Currency Code",                            TempOldVendLedgEntry."Currency Code", NewCVLedgEntryBuf."Posting Date"));                    end;            OnApplyVendLedgEntryOnBeforeTempOldVendLedgEntryDelete(GenJnlLine, TempOldVendLedgEntry, AppliedAmount, NewCVLedgEntryBuf, OldCVLedgEntryBuf);            TempOldVendLedgEntry.Delete();            Completed := FindNextOldVendLedgEntryToApply(GenJnlLine, TempOldVendLedgEntry, NewCVLedgEntryBuf);        until Completed;        DtldCVLedgEntryBuf.SetCurrentKey("CV Ledger Entry No.", "Entry Type");        DtldCVLedgEntryBuf.SetRange("CV Ledger Entry No.", NewCVLedgEntryBuf."Entry No.");        DtldCVLedgEntryBuf.SetRange(          "Entry Type",          DtldCVLedgEntryBuf."Entry Type"::Application);        DtldCVLedgEntryBuf.CalcSums("Amount (LCY)", Amount);        CalcCurrencyUnrealizedGainLoss(          NewCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine, DtldCVLedgEntryBuf.Amount, NewRemainingAmtBeforeAppln);        CalcAmtLCYAdjustment(NewCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine);        NewCVLedgEntryBuf."Applies-to ID" := '';        NewCVLedgEntryBuf."Amount to Apply" := 0;        IsHandled := false;        OnApplyVendLedgEntryOnBeforeUnrealizedVAT(GenJnlLine, NewCVLedgEntryBuf, NewVendLedgEntry, IsHandled);        if not IsHandled then            if GLSetup."Unrealized VAT" or               (GLSetup."Prepayment Unrealized VAT" and NewCVLedgEntryBuf.Prepayment)            then                if IsNotPayment(NewCVLedgEntryBuf."Document Type") and                   (NewRemainingAmtBeforeAppln - NewCVLedgEntryBuf."Remaining Amount" <> 0)                then begin                    NewVendLedgEntry.CopyFromCVLedgEntryBuffer(NewCVLedgEntryBuf);                    CheckUnrealizedVend := true;                    UnrealizedVendLedgEntry := NewVendLedgEntry;                    UnrealizedVendLedgEntry.CalcFields("Amount (LCY)", "Original Amt. (LCY)");                    UnrealizedRemainingAmountVend := -(NewRemainingAmtBeforeAppln - NewVendLedgEntry."Remaining Amount");                end;        OnAfterApplyVendLedgEntry(GenJnlLine, NewCVLedgEntryBuf, OldVendLedgEntry, NewRemainingAmtBeforeAppln);    end;    local procedure FindNextOldVendLedgEntryToApply(GenJnlLine: Record "Gen. Journal Line"; var TempOldVendLedgEntry: Record "Vendor Ledger Entry" temporary; NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer") Completed: Boolean    var        IsHandled: Boolean;    begin        OnBeforeFindNextOldVendLedgEntryToApply(GenJnlLine, TempOldVendLedgEntry, NewCVLedgEntryBuf, Completed, IsHandled);        if IsHandled then            exit(Completed);        if GenJnlLine."Applies-to Doc. No." <> '' then            Completed := true        else            if TempOldVendLedgEntry.GetFilter(Positive) <> '' then                if TempOldVendLedgEntry.Next() = 1 then                    Completed := false                else begin                    TempOldVendLedgEntry.SetRange(Positive);                    TempOldVendLedgEntry.Find('-');                    TempOldVendLedgEntry.CalcFields("Remaining Amount");                    Completed := TempOldVendLedgEntry."Remaining Amount" * NewCVLedgEntryBuf."Remaining Amount" >= 0;                end            else                if NewCVLedgEntryBuf.Open then                    Completed := TempOldVendLedgEntry.Next() = 0                else                    Completed := true;    end;    /// <summary>    /// Prepares and posts employee ledger entries needed for the application. Detailed employee ledger entries are created and posted for both    /// the old and the new employee ledger entry.    /// </summary>    /// <param name="NewCVLedgEntryBuf">Return value: Buffer to collect employee ledger entries that has been created for the application.</param>    /// <param name="DtldCVLedgEntryBuf">Return value: Buffer to collect detailed employee ledger entries that has been created for the application.</param>    /// <param name="GenJnlLine">Gen. journal line that is being posted.</param>    /// <param name="Employee">Employee that the employee ledger entries are created for.</param>    procedure ApplyEmplLedgEntry(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; Employee: Record Employee)    var        OldEmplLedgEntry: Record "Employee Ledger Entry";        OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer";        NewCVLedgEntryBuf2: Record "CV Ledger Entry Buffer";        TempOldEmplLedgEntry: Record "Employee Ledger Entry" temporary;        Completed: Boolean;        AppliedAmount: Decimal;        NewRemainingAmtBeforeAppln: Decimal;        ApplyingDate: Date;        PmtTolAmtToBeApplied: Decimal;        AllApplied: Boolean;    begin        if NewCVLedgEntryBuf."Amount to Apply" = 0 then            exit;        AllApplied := true;        if (GenJnlLine."Applies-to Doc. No." = '') and (GenJnlLine."Applies-to ID" = '') and           not           ((Employee."Application Method" = Employee."Application Method"::"Apply to Oldest") and            GenJnlLine."Allow Application")        then            exit;        PmtTolAmtToBeApplied := 0;        NewRemainingAmtBeforeAppln := NewCVLedgEntryBuf."Remaining Amount";        NewCVLedgEntryBuf2 := NewCVLedgEntryBuf;        ApplyingDate := GenJnlLine."Posting Date";        if not PrepareTempEmplLedgEntry(GenJnlLine, NewCVLedgEntryBuf, TempOldEmplLedgEntry, Employee, ApplyingDate) then            exit;        GenJnlLine."Posting Date" := ApplyingDate;        // Apply the new entry (Payment) to the old entries one at a time        repeat            TempOldEmplLedgEntry.CalcFields(              Amount, "Amount (LCY)", "Remaining Amount", "Remaining Amt. (LCY)",              "Original Amount", "Original Amt. (LCY)");            OldCVLedgEntryBuf.CopyFromEmplLedgEntry(TempOldEmplLedgEntry);            TempOldEmplLedgEntry.CopyFilter(Positive, OldCVLedgEntryBuf.Positive);            PostApply(              GenJnlLine, DtldCVLedgEntryBuf, OldCVLedgEntryBuf, NewCVLedgEntryBuf, NewCVLedgEntryBuf2,              true, AllApplied, AppliedAmount, PmtTolAmtToBeApplied);            // Update the Old Entry            TempOldEmplLedgEntry.CopyFromCVLedgEntryBuffer(OldCVLedgEntryBuf);            OldEmplLedgEntry := TempOldEmplLedgEntry;            OldEmplLedgEntry."Applies-to ID" := '';            OldEmplLedgEntry."Amount to Apply" := 0;            OnApplyEmplLedgEntryOnBeforeOldEmplLedgEntryModify(GenJnlLine, OldEmplLedgEntry, NewCVLedgEntryBuf, AppliedAmount);            OldEmplLedgEntry.Modify();            TempOldEmplLedgEntry.Delete();            Completed := FindNextOldEmplLedgEntryToApply(GenJnlLine, TempOldEmplLedgEntry, NewCVLedgEntryBuf);        until Completed;        DtldCVLedgEntryBuf.SetCurrentKey("CV Ledger Entry No.", "Entry Type");        DtldCVLedgEntryBuf.SetRange("CV Ledger Entry No.", NewCVLedgEntryBuf."Entry No.");        DtldCVLedgEntryBuf.SetRange(          "Entry Type",          DtldCVLedgEntryBuf."Entry Type"::Application);        DtldCVLedgEntryBuf.CalcSums("Amount (LCY)", Amount);        CalcCurrencyUnrealizedGainLoss(          NewCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine, DtldCVLedgEntryBuf.Amount, NewRemainingAmtBeforeAppln);        CalcAmtLCYAdjustment(NewCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine);        NewCVLedgEntryBuf."Applies-to ID" := '';        NewCVLedgEntryBuf."Amount to Apply" := 0;        OnAfterApplyEmplLedgEntry(GenJnlLine, NewCVLedgEntryBuf, OldEmplLedgEntry);    end;    local procedure FindNextOldEmplLedgEntryToApply(GenJnlLine: Record "Gen. Journal Line"; var TempOldEmplLedgEntry: Record "Employee Ledger Entry" temporary; NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer") Completed: Boolean    var        IsHandled: Boolean;    begin        OnBeforeFindNextOldEmplLedgEntryToApply(GenJnlLine, TempOldEmplLedgEntry, NewCVLedgEntryBuf, Completed, IsHandled);        if IsHandled then            exit(Completed);        if GenJnlLine."Applies-to Doc. No." <> '' then            Completed := true        else            if TempOldEmplLedgEntry.GetFilter(Positive) <> '' then                if TempOldEmplLedgEntry.Next() = 1 then                    Completed := false                else begin                    TempOldEmplLedgEntry.SetRange(Positive);                    TempOldEmplLedgEntry.Find('-');                    TempOldEmplLedgEntry.CalcFields("Remaining Amount");                    Completed := TempOldEmplLedgEntry."Remaining Amount" * NewCVLedgEntryBuf."Remaining Amount" >= 0;                end            else                if NewCVLedgEntryBuf.Open then                    Completed := TempOldEmplLedgEntry.Next() = 0                else                    Completed := true;    end;    /// <summary>    /// Stand-alone procedure to post (from check to finish) application gen. journal line for the vendor ledger entries.    /// G/l entries, vat entries, vendor ledger entries and detailed vendor ledger entries are created and posted.    /// </summary>    /// <param name="GenJnlLinePostApply">Gen. journal line that should be posted for application purpose.</param>    /// <param name="VendLedgEntryPostApply">Vendor ledger entry that the new application should be applied to.</param>    procedure VendPostApplyVendLedgEntry(var GenJnlLinePostApply: Record "Gen. Journal Line"; var VendLedgEntryPostApply: Record "Vendor Ledger Entry")    var        Vend: Record Vendor;        VendPostingGr: Record "Vendor Posting Group";        VendLedgEntry: Record "Vendor Ledger Entry";        DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry";        TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary;        CVLedgEntryBuf: Record "CV Ledger Entry Buffer";        GenJnlLine: Record "Gen. Journal Line";        DtldLedgEntryInserted: Boolean;        IsHandled: Boolean;    begin        OnBeforeVendPostApplyVendLedgEntry(GenJnlLinePostApply, VendLedgEntryPostApply);        GenJnlLine := GenJnlLinePostApply;        VendLedgEntry.TransferFields(VendLedgEntryPostApply);        OnVendPostApplyVendLedgEntryOnAfterVendLedgEntryTransferFields(VendLedgEntry, GenJnlLine);        GenJnlLine."Source Currency Code" := VendLedgEntryPostApply."Currency Code";        GenJnlLine."Applies-to ID" := VendLedgEntryPostApply."Applies-to ID";        AmountRoundingPrecision := GetSourceCurrency(GenJnlLine."Source Currency Code");        IsHandled := false;        OnVendPostApplyVendLedgEntryOnBeforeRunCheck(GenJnlLine, IsHandled);        if not IsHandled then            GenJnlCheckLine.RunCheck(GenJnlLine);        if NextEntryNo = 0 then            StartPosting(GenJnlLine)        else            ContinuePosting(GenJnlLine);        Vend.Get(VendLedgEntry."Vendor No.");        Vend.CheckBlockedVendOnJnls(Vend, GenJnlLine."Document Type", true);        OnVendPostApplyVendLedgEntryOnBeforeCheckPostingGroup(GenJnlLine, Vend);        if GenJnlLine."Posting Group" = '' then begin            Vend.TestField("Vendor Posting Group");            GenJnlLine."Posting Group" := Vend."Vendor Posting Group";        end;        GetVendorPostingGroup(GenJnlLine, VendPostingGr);        IsHandled := false;        OnBeforeGetVendorPayablesAccount(GenJnlLine, VendPostingGr, VendPostingGr."Payables Account", IsHandled);        if not IsHandled then            VendPostingGr.GetPayablesAccount();        DtldVendLedgEntry.LockTable();        VendLedgEntry.LockTable();        // Post the application        VendLedgEntry.CalcFields(          Amount, "Amount (LCY)", "Remaining Amount", "Remaining Amt. (LCY)",          "Original Amount", "Original Amt. (LCY)");        OnVendPostApplyVendLedgEntryOnBeforeCopyFromVendLedgEntry(GenJnlLine, CVLedgEntryBuf, VendLedgEntry);        CVLedgEntryBuf.CopyFromVendLedgEntry(VendLedgEntry);        OnVendPostApplyVendLedgEntryOnBeforeApplyVendLedgEntry(VendLedgEntry, GenJnlLine, CVLedgEntryBuf);        ApplyVendLedgEntry(CVLedgEntryBuf, TempDtldCVLedgEntryBuf, GenJnlLine, Vend);        OnVendPostApplyVendLedgEntryOnAfterApplyVendLedgEntry(GenJnlLine, TempDtldCVLedgEntryBuf);        VendLedgEntry.CopyFromCVLedgEntryBuffer(CVLedgEntryBuf);        VendLedgEntry.Modify(true);        // Post Dtld vendor entry        OnVendPostApplyVendLedgEntryOnBeforePostDtldVendLedgEntries(VendLedgEntry);        DtldLedgEntryInserted := PostDtldVendLedgEntries(GenJnlLine, TempDtldCVLedgEntryBuf, VendPostingGr, false);        OnVendPostApplyVendLedgEntryOnBeforeCheckPostUnrealizedVAT(GenJnlLine, TempDtldCVLedgEntryBuf, DtldLedgEntryInserted);        CheckPostUnrealizedVAT(GenJnlLine, true);        if DtldLedgEntryInserted then            if IsTempGLEntryBufEmpty() then                DtldVendLedgEntry.SetZeroTransNo(NextTransactionNo);        OnVendPostApplyVendLedgEntryOnBeforeFinishPosting(GenJnlLine, VendLedgEntry);        FinishPosting(GenJnlLine);        OnAfterVendPostApplyVendLedgEntry(GenJnlLine, GLReg);    end;    /// <summary>    /// Stand-alone procedure to post (from check to finish) application gen. journal line for the employee ledger entries.    /// G/l entries, vat entries, employee ledger entries and detailed employee ledger entries are created and posted.    /// </summary>    /// <param name="GenJnlLinePostApply">Gen. journal line that should be posted for application purpose.</param>    /// <param name="EmplLedgEntryPostApply">Employee ledger entry that the new application should be applied to.</param>    procedure EmplPostApplyEmplLedgEntry(var GenJnlLinePostApply: Record "Gen. Journal Line"; var EmplLedgEntryPostApply: Record "Employee Ledger Entry")    var        Empl: Record Employee;        EmplPostingGr: Record "Employee Posting Group";        EmplLedgEntry: Record "Employee Ledger Entry";        DtldEmplLedgEntry: Record "Detailed Employee Ledger Entry";        TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary;        CVLedgEntryBuf: Record "CV Ledger Entry Buffer";        GenJnlLine: Record "Gen. Journal Line";        DtldLedgEntryInserted: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeEmplPostApplyEmplLedgEntry(GenJnlLinePostApply, EmplLedgEntryPostApply, IsHandled);        if IsHandled then            exit;        GenJnlLine := GenJnlLinePostApply;        EmplLedgEntry.TransferFields(EmplLedgEntryPostApply);        GenJnlLine."Source Currency Code" := EmplLedgEntryPostApply."Currency Code";        GenJnlLine."Applies-to ID" := EmplLedgEntryPostApply."Applies-to ID";        AmountRoundingPrecision := GetSourceCurrency(GenJnlLine."Source Currency Code");        GenJnlCheckLine.RunCheck(GenJnlLine);        if NextEntryNo = 0 then            StartPosting(GenJnlLine)        else            ContinuePosting(GenJnlLine);        Empl.Get(EmplLedgEntry."Employee No.");        if GenJnlLine."Posting Group" = '' then begin            Empl.TestField("Employee Posting Group");            GenJnlLine."Posting Group" := Empl."Employee Posting Group";        end;        EmplPostingGr.Get(GenJnlLine."Posting Group");        IsHandled := false;        OnBeforeGetEmployeePayablesAccount(GenJnlLine, EmplPostingGr, EmplPostingGr."Payables Account", IsHandled);        if not IsHandled then            EmplPostingGr.GetPayablesAccount();        DtldEmplLedgEntry.LockTable();        EmplLedgEntry.LockTable();        // Post the application        EmplLedgEntry.CalcFields(          Amount, "Amount (LCY)", "Remaining Amount", "Remaining Amt. (LCY)",          "Original Amount", "Original Amt. (LCY)");        CVLedgEntryBuf.CopyFromEmplLedgEntry(EmplLedgEntry);        ApplyEmplLedgEntry(          CVLedgEntryBuf, TempDtldCVLedgEntryBuf, GenJnlLine, Empl);        EmplLedgEntry.CopyFromCVLedgEntryBuffer(CVLedgEntryBuf);        EmplLedgEntry.Modify(true);        // Post Dtld vendor entry        DtldLedgEntryInserted := PostDtldEmplLedgEntries(GenJnlLine, TempDtldCVLedgEntryBuf, EmplPostingGr, false);        CheckPostUnrealizedVAT(GenJnlLine, true);        if DtldLedgEntryInserted then            if IsTempGLEntryBufEmpty() then                DtldEmplLedgEntry.SetZeroTransNo(NextTransactionNo);        FinishPosting(GenJnlLine);    end;    local procedure PrepareTempVendLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var TempOldVendLedgEntry: Record "Vendor Ledger Entry" temporary; Vend: Record Vendor; var ApplyingDate: Date): Boolean    var        OldVendLedgEntry: Record "Vendor Ledger Entry";        PurchSetup: Record "Purchases & Payables Setup";        GenJnlApply: Codeunit "Gen. Jnl.-Apply";        RemainingAmount: Decimal;        IsHandled: Boolean;        Result: Boolean;        SufficientEntriesFound: Boolean;        NextStep: Integer;    begin        IsHandled := false;        OnBeforePrepareTempVendLedgEntry(GenJnlLine, NewCVLedgEntryBuf, TempOldVendLedgEntry, Vend, ApplyingDate, Result, IsHandled);        if IsHandled then            exit(Result);        if GenJnlLine."Applies-to Doc. No." <> '' then begin            // Find the entry to be applied to            OldVendLedgEntry.Reset();            OldVendLedgEntry.SetLoadFields(Positive, "Posting Date", "Currency Code");            OldVendLedgEntry.SetCurrentKey("Document No.");            OldVendLedgEntry.SetRange("Document No.", GenJnlLine."Applies-to Doc. No.");            OldVendLedgEntry.SetRange("Document Type", GenJnlLine."Applies-to Doc. Type");            OldVendLedgEntry.SetRange("Vendor No.", NewCVLedgEntryBuf."CV No.");            OldVendLedgEntry.SetRange(Open, true);            OnPrepareTempVendLedgEntryOnAfterSetFilters(OldVendLedgEntry, GenJnlLine, NewCVLedgEntryBuf);            OldVendLedgEntry.FindFirst();            IsHandled := false;            OnPrepareTempVendLedgEntryOnBeforeTestPositive(GenJnlLine, IsHandled);            if not IsHandled then                OldVendLedgEntry.TestField(Positive, not NewCVLedgEntryBuf.Positive);            if OldVendLedgEntry."Posting Date" > ApplyingDate then                ApplyingDate := OldVendLedgEntry."Posting Date";            OnPrepareTempVendLedgEntryOnBeforeCheckAgainstApplnCurrencyWithAppliesToDocNo(GenJnlLine, NewCVLedgEntryBuf, OldVendLedgEntry);            GenJnlApply.CheckAgainstApplnCurrency(              NewCVLedgEntryBuf."Currency Code", OldVendLedgEntry."Currency Code", GenJnlLine."Account Type"::Vendor, true);            TempOldVendLedgEntry := OldVendLedgEntry;            OnPrepareTempVendLedgEntryOnBeforeTempOldVendLedgEntryInsert(TempOldVendLedgEntry, GenJnlLine);            TempOldVendLedgEntry.Insert();        end else begin            // Find the first old entry (Invoice) which the new entry (Payment) should apply to            OldVendLedgEntry.Reset();            OldVendLedgEntry.SetLoadFields("Posting Date", "Currency Code", "Applies-to ID");            OldVendLedgEntry.SetCurrentKey("Vendor No.", "Applies-to ID", Open, Positive, "Due Date");            TempOldVendLedgEntry.SetCurrentKey("Vendor No.", "Applies-to ID", Open, Positive, "Due Date");            OldVendLedgEntry.SetRange("Vendor No.", NewCVLedgEntryBuf."CV No.");            OldVendLedgEntry.SetRange("Applies-to ID", GenJnlLine."Applies-to ID");            OldVendLedgEntry.SetRange(Open, true);            OldVendLedgEntry.SetFilter("Entry No.", '<>%1', NewCVLedgEntryBuf."Entry No.");            if not (Vend."Application Method" = Vend."Application Method"::"Apply to Oldest") then                OldVendLedgEntry.SetFilter("Amount to Apply", '<>%1', 0);            if Vend."Application Method" = Vend."Application Method"::"Apply to Oldest" then                OldVendLedgEntry.SetFilter("Posting Date", '..%1', GenJnlLine."Posting Date");            // Check and Move Ledger Entries to Temp            PurchSetup.Get();            if PurchSetup."Appln. between Currencies" = PurchSetup."Appln. between Currencies"::None then                OldVendLedgEntry.SetRange("Currency Code", NewCVLedgEntryBuf."Currency Code");            OnPrepareTempVendLedgEntryOnAfterSetFiltersBlankAppliesToDocNo(OldVendLedgEntry, GenJnlLine, NewCVLedgEntryBuf, Vend);            if OldVendLedgEntry.FindSet(false) then                repeat                    OnPrepareTempVendLedgEntryOnBeforeCheckAgainstApplnCurrency(GenJnlLine, NewCVLedgEntryBuf, OldVendLedgEntry);                    if GenJnlApply.CheckAgainstApplnCurrency(                         NewCVLedgEntryBuf."Currency Code", OldVendLedgEntry."Currency Code", GenJnlLine."Account Type"::Vendor, false)                    then begin                        if (OldVendLedgEntry."Posting Date" > ApplyingDate) and (OldVendLedgEntry."Applies-to ID" <> '') then                            ApplyingDate := OldVendLedgEntry."Posting Date";                        TempOldVendLedgEntry := OldVendLedgEntry;                        OnPrepareTempVendLedgEntryOnBeforeTempOldVendLedgEntryInsert(TempOldVendLedgEntry, GenJnlLine);                        TempOldVendLedgEntry.Insert();                    end;                until OldVendLedgEntry.Next() = 0;            TempOldVendLedgEntry.SetRange(Positive, NewCVLedgEntryBuf."Remaining Amount" > 0);            if TempOldVendLedgEntry.Find('-') then begin                RemainingAmount := NewCVLedgEntryBuf."Remaining Amount";                TempOldVendLedgEntry.SetRange(Positive);                // Weigh the entries of the same sign as the new document before the opposite-sign ones.                // The sign decision below is a property of the whole open-entry set, so the early exit                // must not stop before the opposite-sign entries have settled that sign.                if NewCVLedgEntryBuf."Remaining Amount" > 0 then begin                    TempOldVendLedgEntry.Find('+');                    NextStep := -1;                end else begin                    TempOldVendLedgEntry.Find('-');                    NextStep := 1;                end;                repeat                    TempOldVendLedgEntry.CalcFields("Remaining Amount");                    TempOldVendLedgEntry.RecalculateAmounts(                      TempOldVendLedgEntry."Currency Code", NewCVLedgEntryBuf."Currency Code", NewCVLedgEntryBuf."Posting Date");                    if PaymentToleranceMgt.CheckCalcPmtDiscCVVend(NewCVLedgEntryBuf, TempOldVendLedgEntry, 0, false, false) then                        TempOldVendLedgEntry."Remaining Amount" -= TempOldVendLedgEntry.GetRemainingPmtDiscPossible(NewCVLedgEntryBuf."Posting Date");                    RemainingAmount += TempOldVendLedgEntry."Remaining Amount";                    if (Vend."Application Method" = Vend."Application Method"::"Apply to Oldest") and                       (RemainingAmount * NewCVLedgEntryBuf."Remaining Amount" < 0)                    then                        SufficientEntriesFound := true;                until (TempOldVendLedgEntry.Next(NextStep) = 0) or SufficientEntriesFound;                TempOldVendLedgEntry.SetRange(Positive, RemainingAmount < 0);            end else                TempOldVendLedgEntry.SetRange(Positive);            OnPrepareTempVendLedgEntryOnBeforeExit(GenJnlLine, NewCVLedgEntryBuf, TempOldVendLedgEntry);            exit(TempOldVendLedgEntry.Find('-'));        end;        exit(true);    end;    local procedure PrepareTempEmplLedgEntry(GenJnlLine: Record "Gen. Journal Line"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var TempOldEmplLedgEntry: Record "Employee Ledger Entry" temporary; Employee: Record Employee; var ApplyingDate: Date): Boolean    var        OldEmplLedgEntry: Record "Employee Ledger Entry";        RemainingAmount: Decimal;        IsHandled: Boolean;        Result: Boolean;        SufficientEntriesFound: Boolean;        NextStep: Integer;    begin        IsHandled := false;        OnBeforePrepareTempEmplLedgEntry(GenJnlLine, NewCVLedgEntryBuf, TempOldEmplLedgEntry, Employee, ApplyingDate, Result, IsHandled);        if IsHandled then            exit(Result);        if GenJnlLine."Applies-to Doc. No." <> '' then begin            // Find the entry to be applied to            OldEmplLedgEntry.Reset();            OldEmplLedgEntry.SetCurrentKey("Document No.");            OldEmplLedgEntry.SetRange("Document Type", GenJnlLine."Applies-to Doc. Type");            OldEmplLedgEntry.SetRange("Document No.", GenJnlLine."Applies-to Doc. No.");            OldEmplLedgEntry.SetRange("Employee No.", NewCVLedgEntryBuf."CV No.");            OldEmplLedgEntry.SetRange(Open, true);            OldEmplLedgEntry.FindFirst();            IsHandled := false;            OnPrepareTempVendLedgEntryOnBeforeTestPositive(GenJnlLine, IsHandled);            if not IsHandled then                OldEmplLedgEntry.TestField(Positive, not NewCVLedgEntryBuf.Positive);            if OldEmplLedgEntry."Posting Date" > ApplyingDate then                ApplyingDate := OldEmplLedgEntry."Posting Date";            TempOldEmplLedgEntry := OldEmplLedgEntry;            OnPrepareTempEmplLedgEntryOnAppDocNoOnBeforeTempOldEmplLedgEntryInsert(TempOldEmplLedgEntry, GenJnlLine);            TempOldEmplLedgEntry.Insert();        end else begin            // Find the first old entry which the new entry (Payment) should apply to            OldEmplLedgEntry.Reset();            OldEmplLedgEntry.SetCurrentKey("Employee No.", "Applies-to ID", Open, Positive);            TempOldEmplLedgEntry.SetCurrentKey("Employee No.", "Applies-to ID", Open, Positive);            OldEmplLedgEntry.SetRange("Employee No.", NewCVLedgEntryBuf."CV No.");            OldEmplLedgEntry.SetRange("Applies-to ID", GenJnlLine."Applies-to ID");            OldEmplLedgEntry.SetRange(Open, true);            OldEmplLedgEntry.SetFilter("Entry No.", '<>%1', NewCVLedgEntryBuf."Entry No.");            if not (Employee."Application Method" = Employee."Application Method"::"Apply to Oldest") then                OldEmplLedgEntry.SetFilter("Amount to Apply", '<>%1', 0);            if Employee."Application Method" = Employee."Application Method"::"Apply to Oldest" then                OldEmplLedgEntry.SetFilter("Posting Date", '..%1', GenJnlLine."Posting Date");            OnPrepareTempEmplLedgEntryOnAfterSetFiltersByAppliesToId(OldEmplLedgEntry, GenJnlLine, NewCVLedgEntryBuf, Employee);            if OldEmplLedgEntry.FindSet(false) then                repeat                    if (OldEmplLedgEntry."Posting Date" > ApplyingDate) and (OldEmplLedgEntry."Applies-to ID" <> '') then                        ApplyingDate := OldEmplLedgEntry."Posting Date";                    TempOldEmplLedgEntry := OldEmplLedgEntry;                    OnPrepareTempEmplLedgEntryOnAppToIDOnBeforeTempOldEmplLedgEntryInsert(TempOldEmplLedgEntry, GenJnlLine);                    TempOldEmplLedgEntry.Insert();                until OldEmplLedgEntry.Next() = 0;            TempOldEmplLedgEntry.SetRange(Positive, NewCVLedgEntryBuf."Remaining Amount" > 0);            if TempOldEmplLedgEntry.Find('-') then begin                RemainingAmount := NewCVLedgEntryBuf."Remaining Amount";                TempOldEmplLedgEntry.SetRange(Positive);                // Weigh the entries of the same sign as the new document before the opposite-sign ones.                // The sign decision below is a property of the whole open-entry set, so the early exit                // must not stop before the opposite-sign entries have settled that sign.                if NewCVLedgEntryBuf."Remaining Amount" > 0 then begin                    TempOldEmplLedgEntry.Find('+');                    NextStep := -1;                end else begin                    TempOldEmplLedgEntry.Find('-');                    NextStep := 1;                end;                repeat                    TempOldEmplLedgEntry.CalcFields("Remaining Amount");                    TempOldEmplLedgEntry.RecalculateAmounts(                      TempOldEmplLedgEntry."Currency Code", NewCVLedgEntryBuf."Currency Code", NewCVLedgEntryBuf."Posting Date");                    OnPrepareTempEmplLedgEntryOnBeforeUpdateRemainingAmount(TempOldEmplLedgEntry, NewCVLedgEntryBuf);                    RemainingAmount += TempOldEmplLedgEntry."Remaining Amount";                    if (Employee."Application Method" = Employee."Application Method"::"Apply to Oldest") and                       (RemainingAmount * NewCVLedgEntryBuf."Remaining Amount" < 0)                    then                        SufficientEntriesFound := true;                until (TempOldEmplLedgEntry.Next(NextStep) = 0) or SufficientEntriesFound;                TempOldEmplLedgEntry.SetRange(Positive, RemainingAmount < 0);            end else                TempOldEmplLedgEntry.SetRange(Positive);            exit(TempOldEmplLedgEntry.Find('-'));        end;        exit(true);    end;    /// <summary>    /// Posts all detailed vendor ledger entries that are stored in DtldCVLedgEntryBuf. Creates g/l entry for the total amounts.    /// </summary>    /// <remarks>    /// DtldCVLedgEntryBuf is cleared after the procedure is finished.    /// </remarks>    /// <param name="GenJournalLine">Gen. journal line that is being posted.</param>    /// <param name="DetailedCVLedgEntryBuffer">Detailed vendor ledger entries to be inserted and posted.</param>    /// <param name="VendPostingGr">Vendor posting group to be used for detailed vendor ledger entries.</param>    /// <param name="LedgEntryInserted">Flag if vendor ledger entries have already been created in the same transaction.</param>    /// <returns>True if any detailed vendor ledger entries has been created.</returns>    procedure PostDtldVendLedgEntries(GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; VendPostingGr: Record "Vendor Posting Group"; LedgEntryInserted: Boolean) DtldLedgEntryInserted: Boolean    var        TempDimensionPostingBuffer: Record "Dimension Posting Buffer" temporary;        DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry";        AdjAmount: array[4] of Decimal;        DtldVendLedgEntryNoOffset: Integer;        SaveEntryNo: Integer;        IsHandled: Boolean;    begin        if GenJournalLine."Account Type" <> GenJournalLine."Account Type"::Vendor then            exit;        OnPostDtldVendLedgEntriesOnBeforeSetDtldVendLedgEntryNoOffset(GenJournalLine, DetailedVendorLedgEntry);        if DetailedVendorLedgEntry.FindLast() then            DtldVendLedgEntryNoOffset := DetailedVendorLedgEntry."Entry No."        else            DtldVendLedgEntryNoOffset := 0;        OnPostDtldVendLedgEntriesOnAfterSetDtldVendLedgEntryNoOffset(GenJournalLine, DetailedVendorLedgEntry, DtldVendLedgEntryNoOffset);        MultiplePostingGroups := CheckVendMultiplePostingGroups(DetailedCVLedgEntryBuffer);        DetailedCVLedgEntryBuffer.Reset();        OnAfterSetDtldVendLedgEntryNoOffset(DetailedCVLedgEntryBuffer, DtldVendLedgEntryNoOffset);        if DetailedCVLedgEntryBuffer.FindSet() then begin            if LedgEntryInserted then begin                SaveEntryNo := NextEntryNo;                IncrNextEntryNo();            end;            repeat                InsertDtldVendLedgEntry(GenJournalLine, DetailedCVLedgEntryBuffer, DetailedVendorLedgEntry, DtldVendLedgEntryNoOffset);                IsHandled := false;                OnPostDtldVendLedgEntriesOnBeforeUpdateTotalAmounts(GenJournalLine, DetailedVendorLedgEntry, IsHandled, DetailedCVLedgEntryBuffer);                if not IsHandled then                    UpdateTotalAmounts(TempDimensionPostingBuffer, GenJournalLine."Dimension Set ID", DetailedCVLedgEntryBuffer);                IsHandled := false;                OnPostDtldVendLedgEntriesOnBeforePostDtldVendLedgEntry(GenJournalLine, DetailedCVLedgEntryBuffer, VendPostingGr, AdjAmount, IsHandled, LedgEntryInserted);                if not IsHandled then                    if ((DetailedCVLedgEntryBuffer."Amount (LCY)" <> 0) or                        (DetailedCVLedgEntryBuffer."VAT Amount (LCY)" <> 0)) or                       ((AddCurrencyCode <> '') and (DetailedCVLedgEntryBuffer."Additional-Currency Amount" <> 0))                    then                        PostDtldVendLedgEntry(GenJournalLine, DetailedCVLedgEntryBuffer, VendPostingGr, AdjAmount);                OnPostDtldVendLedgEntriesOnAfterPostDtldVendLedgEntry(DetailedCVLedgEntryBuffer, DetailedVendorLedgEntry, LedgEntryInserted);            until DetailedCVLedgEntryBuffer.Next() = 0;        end;        IsHandled := false;        OnPostDtldVendLedgEntriesOnBeforeCreateGLEntriesForTotalAmounts(VendPostingGr, DetailedCVLedgEntryBuffer, GenJournalLine, TempDimensionPostingBuffer, AdjAmount, SaveEntryNo, LedgEntryInserted, IsHandled);        if not IsHandled then            CreateGLEntriesForTotalAmounts(                GenJournalLine, TempDimensionPostingBuffer, AdjAmount, SaveEntryNo, GetVendorPayablesAccount2(DetailedCVLedgEntryBuffer, GenJournalLine, VendPostingGr), LedgEntryInserted);        OnPostDtldVendLedgEntriesOnAfterCreateGLEntriesForTotalAmounts(TempGLEntryBuf, GlobalGLEntry, NextTransactionNo);        DtldLedgEntryInserted := not DetailedCVLedgEntryBuffer.IsEmpty();        DetailedCVLedgEntryBuffer.DeleteAll();    end;    local procedure PostDtldVendLedgEntry(GenJournalLine: Record "Gen. Journal Line"; DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; VendPostingGr: Record "Vendor Posting Group"; var AdjAmount: array[4] of Decimal)    var        AccNo: Code[20];    begin        if MultiplePostingGroups and (DetailedCVLedgEntryBuffer."Entry Type" = DetailedCVLedgEntryBuffer."Entry Type"::Application) then            AccNo := GetVendDtldCVLedgEntryBufferAccNo(GenJournalLine, DetailedCVLedgEntryBuffer)        else            AccNo := GetDtldVendLedgEntryAccNo(GenJournalLine, DetailedCVLedgEntryBuffer, VendPostingGr, 0, false);        PostDtldCVLedgEntry(GenJournalLine, DetailedCVLedgEntryBuffer, AccNo, AdjAmount, false);    end;    local procedure PostDtldVendLedgEntryUnapply(GenJournalLine: Record "Gen. Journal Line"; DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; VendPostingGr: Record "Vendor Posting Group"; OriginalTransactionNo: Integer)    var        AccNo: Code[20];        AdjAmount: array[4] of Decimal;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostDtldVendLedgEntryUnapply(GenJournalLine, DetailedCVLedgEntryBuffer, VendPostingGr, OriginalTransactionNo, IsHandled);        if IsHandled then            exit;        if (DetailedCVLedgEntryBuffer."Amount (LCY)" = 0) and           (DetailedCVLedgEntryBuffer."VAT Amount (LCY)" = 0) and           ((AddCurrencyCode = '') or (DetailedCVLedgEntryBuffer."Additional-Currency Amount" = 0))        then            exit;        if MultiplePostingGroups and (DetailedCVLedgEntryBuffer."Entry Type" = DetailedCVLedgEntryBuffer."Entry Type"::Application) then            AccNo := GetVendDtldCVLedgEntryBufferAccNo(GenJournalLine, DetailedCVLedgEntryBuffer)        else            AccNo := GetDtldVendLedgEntryAccNo(GenJournalLine, DetailedCVLedgEntryBuffer, VendPostingGr, OriginalTransactionNo, true);        DetailedCVLedgEntryBuffer."Gen. Posting Type" := DetailedCVLedgEntryBuffer."Gen. Posting Type"::Purchase;        PostDtldCVLedgEntry(GenJournalLine, DetailedCVLedgEntryBuffer, AccNo, AdjAmount, true);    end;    local procedure GetDtldVendLedgEntryAccNo(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; VendPostingGr: Record "Vendor Posting Group"; OriginalTransactionNo: Integer; Unapply: Boolean) AccountNo: Code[20]    var        Currency: Record Currency;        GenPostingSetup: Record "General Posting Setup";        AmountCondition: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetDtldVendLedgEntryAccNo(GenJnlLine, DtldCVLedgEntryBuf, VendPostingGr, OriginalTransactionNo, Unapply, VATEntry, AccountNo, IsHandled);        if IsHandled then            exit;        AmountCondition := IsDebitAmount(DtldCVLedgEntryBuf, Unapply);        case DtldCVLedgEntryBuf."Entry Type" of            DtldCVLedgEntryBuf."Entry Type"::"Initial Entry":                ;            DtldCVLedgEntryBuf."Entry Type"::Application:                ;            DtldCVLedgEntryBuf."Entry Type"::"Unrealized Loss",            DtldCVLedgEntryBuf."Entry Type"::"Unrealized Gain",            DtldCVLedgEntryBuf."Entry Type"::"Realized Loss",            DtldCVLedgEntryBuf."Entry Type"::"Realized Gain":                begin                    GetCurrency(Currency, DtldCVLedgEntryBuf."Currency Code");                    CheckNonAddCurrCodeOccurred(Currency.Code);                    exit(Currency.GetGainLossAccount(DtldCVLedgEntryBuf));                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount":                exit(VendPostingGr.GetPmtDiscountAccount(AmountCondition));            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Excl.)":                begin                    GenPostingSetup.Get(DtldCVLedgEntryBuf."Gen. Bus. Posting Group", DtldCVLedgEntryBuf."Gen. Prod. Posting Group");                    exit(GenPostingSetup.GetPurchPmtDiscountAccount(AmountCondition));                end;            DtldCVLedgEntryBuf."Entry Type"::"Appln. Rounding":                exit(VendPostingGr.GetApplRoundingAccount(AmountCondition));            DtldCVLedgEntryBuf."Entry Type"::"Correction of Remaining Amount":                exit(VendPostingGr.GetRoundingAccount(AmountCondition));            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance":                case GLSetup."Pmt. Disc. Tolerance Posting" of                    GLSetup."Pmt. Disc. Tolerance Posting"::"Payment Tolerance Accounts":                        exit(VendPostingGr.GetPmtToleranceAccount(AmountCondition));                    GLSetup."Pmt. Disc. Tolerance Posting"::"Payment Discount Accounts":                        exit(VendPostingGr.GetPmtDiscountAccount(AmountCondition));                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance":                case GLSetup."Payment Tolerance Posting" of                    GLSetup."Payment Tolerance Posting"::"Payment Tolerance Accounts":                        exit(VendPostingGr.GetPmtToleranceAccount(AmountCondition));                    GLSetup."Payment Tolerance Posting"::"Payment Discount Accounts":                        exit(VendPostingGr.GetPmtDiscountAccount(AmountCondition));                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Excl.)":                begin                    GenPostingSetup.Get(DtldCVLedgEntryBuf."Gen. Bus. Posting Group", DtldCVLedgEntryBuf."Gen. Prod. Posting Group");                    case GLSetup."Payment Tolerance Posting" of                        GLSetup."Payment Tolerance Posting"::"Payment Tolerance Accounts":                            exit(GenPostingSetup.GetPurchPmtToleranceAccount(AmountCondition));                        GLSetup."Payment Tolerance Posting"::"Payment Discount Accounts":                            exit(GenPostingSetup.GetPurchPmtDiscountAccount(AmountCondition));                    end;                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Excl.)":                begin                    GenPostingSetup.Get(DtldCVLedgEntryBuf."Gen. Bus. Posting Group", DtldCVLedgEntryBuf."Gen. Prod. Posting Group");                    case GLSetup."Pmt. Disc. Tolerance Posting" of                        GLSetup."Pmt. Disc. Tolerance Posting"::"Payment Tolerance Accounts":                            exit(GenPostingSetup.GetPurchPmtToleranceAccount(AmountCondition));                        GLSetup."Pmt. Disc. Tolerance Posting"::"Payment Discount Accounts":                            exit(GenPostingSetup.GetPurchPmtDiscountAccount(AmountCondition));                    end;                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Adjustment)",          DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Adjustment)",          DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Adjustment)":                if Unapply then                    PostDtldVendVATAdjustment(GenJnlLine, DtldCVLedgEntryBuf, OriginalTransactionNo);            else                DtldCVLedgEntryBuf.FieldError("Entry Type");        end;    end;    local procedure PostDtldEmplLedgEntry(GenJournalLine: Record "Gen. Journal Line"; DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; EmplPostingGr: Record "Employee Posting Group"; var AdjAmount: array[4] of Decimal)    var        AccNo: Code[20];    begin        if MultiplePostingGroups and (DetailedCVLedgEntryBuffer."Entry Type" = DetailedCVLedgEntryBuffer."Entry Type"::Application) then            AccNo := GetEmplDtldCVLedgEntryBufferAccNo(GenJournalLine, DetailedCVLedgEntryBuffer)        else            AccNo := GetDtldEmplLedgEntryAccNo(GenJournalLine, DetailedCVLedgEntryBuffer, EmplPostingGr, 0, false);        PostDtldCVLedgEntry(GenJournalLine, DetailedCVLedgEntryBuffer, AccNo, AdjAmount, false);    end;    local procedure PostDtldEmplLedgEntryUnapply(GenJournalLine: Record "Gen. Journal Line"; DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; EmplPostingGr: Record "Employee Posting Group"; OriginalTransactionNo: Integer)    var        AccNo: Code[20];        AdjAmount: array[4] of Decimal;    begin        if (DetailedCVLedgEntryBuffer."Amount (LCY)" = 0) and           ((AddCurrencyCode = '') or (DetailedCVLedgEntryBuffer."Additional-Currency Amount" = 0))        then            exit;        if MultiplePostingGroups and (DetailedCVLedgEntryBuffer."Entry Type" = DetailedCVLedgEntryBuffer."Entry Type"::Application) then            AccNo := GetEmplDtldCVLedgEntryBufferAccNo(GenJournalLine, DetailedCVLedgEntryBuffer)        else            AccNo := GetDtldEmplLedgEntryAccNo(GenJournalLine, DetailedCVLedgEntryBuffer, EmplPostingGr, OriginalTransactionNo, true);        DetailedCVLedgEntryBuffer."Gen. Posting Type" := DetailedCVLedgEntryBuffer."Gen. Posting Type"::Purchase;        PostDtldCVLedgEntry(GenJournalLine, DetailedCVLedgEntryBuffer, AccNo, AdjAmount, true);    end;    local procedure GetDtldEmplLedgEntryAccNo(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; EmplPostingGr: Record "Employee Posting Group"; OriginalTransactionNo: Integer; Unapply: Boolean) AccountNo: Code[20]    var        Currency: Record Currency;        AmountCondition: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetDtldEmplLedgEntryAccNo(GenJnlLine, DtldCVLedgEntryBuf, EmplPostingGr, OriginalTransactionNo, Unapply, AccountNo, IsHandled);        if IsHandled then            exit;        AmountCondition := IsDebitAmount(DtldCVLedgEntryBuf, Unapply);        case DtldCVLedgEntryBuf."Entry Type" of            DtldCVLedgEntryBuf."Entry Type"::"Initial Entry":                ;            DtldCVLedgEntryBuf."Entry Type"::Application:                ;            DtldCVLedgEntryBuf."Entry Type"::"Unrealized Loss",            DtldCVLedgEntryBuf."Entry Type"::"Unrealized Gain",            DtldCVLedgEntryBuf."Entry Type"::"Realized Loss",            DtldCVLedgEntryBuf."Entry Type"::"Realized Gain":                begin                    GetCurrency(Currency, DtldCVLedgEntryBuf."Currency Code");                    CheckNonAddCurrCodeOccurred(Currency.Code);                    exit(Currency.GetGainLossAccount(DtldCVLedgEntryBuf));                end;            DtldCVLedgEntryBuf."Entry Type"::"Appln. Rounding":                exit(EmplPostingGr.GetApplRoundingAccount(AmountCondition));            DtldCVLedgEntryBuf."Entry Type"::"Correction of Remaining Amount":                exit(EmplPostingGr.GetRoundingAccount(AmountCondition));            else                DtldCVLedgEntryBuf.FieldError("Entry Type");        end;    end;    local procedure GetCustDtldCVLedgEntryBufferAccNo(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"): Code[20]    var        CustLedgerEntry: Record "Cust. Ledger Entry";        CustomerPostingGroup: Record "Customer Posting Group";    begin        CustLedgerEntry.Get(DetailedCVLedgEntryBuffer."CV Ledger Entry No.");        CustomerPostingGroup.Get(CustLedgerEntry."Customer Posting Group");        exit(GetCustomerReceivablesAccount(GenJournalLine, CustomerPostingGroup));    end;    local procedure GetVendDtldCVLedgEntryBufferAccNo(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"): Code[20]    var        VendorLedgerEntry: Record "Vendor Ledger Entry";        VendorPostingGroup: Record "Vendor Posting Group";    begin        VendorLedgerEntry.Get(DetailedCVLedgEntryBuffer."CV Ledger Entry No.");        VendorPostingGroup.Get(VendorLedgerEntry."Vendor Posting Group");        exit(GetVendorPayablesAccount(GenJournalLine, VendorPostingGroup));    end;    local procedure GetEmplDtldCVLedgEntryBufferAccNo(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"): Code[20]    var        EmployeeLedgerEntry: Record "Employee Ledger Entry";        EmployeePostingGroup: Record "Employee Posting Group";    begin        EmployeeLedgerEntry.Get(DetailedCVLedgEntryBuffer."CV Ledger Entry No.");        EmployeePostingGroup.Get(EmployeeLedgerEntry."Employee Posting Group");        exit(GetEmployeePayablesAccount(GenJournalLine, EmployeePostingGroup));    end;    /// <summary>    /// Posts all detailed employee ledger entries that are stored in DtldCVLedgEntryBuf. Creates g/l entry for the total amounts.    /// </summary>    /// <remarks>    /// DtldCVLedgEntryBuf is cleared after the procedure is finished.    /// </remarks>    /// <param name="GenJournalLine">Gen. journal line that is being posted.</param>    /// <param name="DetailedCVLedgEntryBuffer">Detailed employee ledger entries to be inserted and posted.</param>    /// <param name="EmplPostingGr">Employee posting group to be used for detailed employee ledger entries.</param>    /// <param name="LedgEntryInserted">Flag if employee ledger entries have already been created in the same transaction.</param>    /// <returns>True if any detailed employee ledger entries has been created.</returns>    procedure PostDtldEmplLedgEntries(GenJnlLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; EmplPostingGr: Record "Employee Posting Group"; LedgEntryInserted: Boolean) DtldLedgEntryInserted: Boolean    var        TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary;        DtldEmplLedgEntry: Record "Detailed Employee Ledger Entry";        AdjAmount: array[4] of Decimal;        DtldEmplLedgEntryNoOffset: Integer;        SaveEntryNo: Integer;        IsHandled: Boolean;    begin        if GenJnlLine."Account Type" <> GenJnlLine."Account Type"::Employee then            exit;        if DtldEmplLedgEntry.FindLast() then            DtldEmplLedgEntryNoOffset := DtldEmplLedgEntry."Entry No."        else            DtldEmplLedgEntryNoOffset := 0;        MultiplePostingGroups := CheckEmplMultiplePostingGroups(DtldCVLedgEntryBuf);        DtldCVLedgEntryBuf.Reset();        OnAfterSetDtldEmplLedgEntryNoOffset(DtldCVLedgEntryBuf, DtldEmplLedgEntryNoOffset);        if DtldCVLedgEntryBuf.FindSet() then begin            if LedgEntryInserted then begin                SaveEntryNo := NextEntryNo;                IncrNextEntryNo();            end;            repeat                InsertDtldEmplLedgEntry(GenJnlLine, DtldCVLedgEntryBuf, DtldEmplLedgEntry, DtldEmplLedgEntryNoOffset);                IsHandled := false;                OnPostDtldEmplLedgEntriesOnBeforeUpdateTotalAmounts(GenJnlLine, DtldCVLedgEntryBuf, DtldEmplLedgEntry, IsHandled);                if not IsHandled then                    UpdateTotalAmounts(TempDimPostingBuffer, GenJnlLine."Dimension Set ID", DtldCVLedgEntryBuf);                IsHandled := false;                OnPostDtldEmplLedgEntriesOnAfterUpdateTotalAmounts(GenJnlLine, DtldCVLedgEntryBuf, DtldEmplLedgEntry);                if not IsHandled then                    if (DtldCVLedgEntryBuf."Amount (LCY)" <> 0) or                       ((AddCurrencyCode <> '') and (DtldCVLedgEntryBuf."Additional-Currency Amount" <> 0))                    then                        PostDtldEmplLedgEntry(GenJnlLine, DtldCVLedgEntryBuf, EmplPostingGr, AdjAmount);            until DtldCVLedgEntryBuf.Next() = 0;        end;        IsHandled := false;        OnPostDtldEmplLedgEntriesOnBeforeCreateGLEntriesForTotalAmounts(EmplPostingGr, DtldCVLedgEntryBuf, GenJnlLine, TempDimPostingBuffer, AdjAmount, SaveEntryNo, LedgEntryInserted, IsHandled);        if not IsHandled then            CreateGLEntriesForTotalAmounts(              GenJnlLine, TempDimPostingBuffer, AdjAmount, SaveEntryNo, GetEmployeePayablesAccount(GenJnlLine, EmplPostingGr), LedgEntryInserted);        OnPostDtldEmplLedgEntriesOnAfterCreateGLEntriesForTotalAmounts(TempGLEntryBuf, GlobalGLEntry, NextTransactionNo);        DtldLedgEntryInserted := not DtldCVLedgEntryBuf.IsEmpty();        DtldCVLedgEntryBuf.DeleteAll();    end;    /// <summary>    /// Depending on the detailed customer/vendor ledger entry type, creates g/l entry and other entries for the detailed customer/vendor ledger entry.    /// If general journal line is created not for the unapplication purpose, adjustments can be collected.    /// </summary>    /// <param name="GenJournalLine">Gen. journal line that is being posted.</param>    /// <param name="DetailedCVLedgEntryBuffer">Detailed customer/vendor ledger entry to post.</param>    /// <param name="AccNo">G/l account to be used for g/l entry.</param>    /// <param name="AdjAmount">Return value: array for adjustments.</param>    /// <param name="Unapply">Flag if the posting is for unapplication.</param>    procedure PostDtldCVLedgEntry(GenJournalLine: Record "Gen. Journal Line"; DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; AccNo: Code[20]; var AdjAmount: array[4] of Decimal; Unapply: Boolean)    var        CustomerPostingGroup: Record "Customer Posting Group";        EmployeePostingGroup: Record "Employee Posting Group";        AccNo2: Code[20];        AccNo3: Code[20];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostDtldCVLedgEntry(GenJournalLine, DetailedCVLedgEntryBuffer, AccNo, Unapply, AdjAmount, IsHandled, AddCurrencyCode, MultiplePostingGroups);        if IsHandled then            exit;        case DetailedCVLedgEntryBuffer."Entry Type" of            DetailedCVLedgEntryBuffer."Entry Type"::"Initial Entry":                ;            DetailedCVLedgEntryBuffer."Entry Type"::Application:                if MultiplePostingGroups then                    CreateGLEntry(                        GenJournalLine, AccNo, DetailedCVLedgEntryBuffer."Amount (LCY)",                        GLCalcAddCurrency(                            DetailedCVLedgEntryBuffer."Amount (LCY)", DetailedCVLedgEntryBuffer.Amount, 0,                            DetailedCVLedgEntryBuffer."Currency Code" = AddCurrencyCode, GenJournalLine),                        DetailedCVLedgEntryBuffer."Currency Code" = AddCurrencyCode,                        CalcAmountSrcCurr(GenJournalLine, DetailedCVLedgEntryBuffer."Amount (LCY)"));            DetailedCVLedgEntryBuffer."Entry Type"::"Unrealized Loss",            DetailedCVLedgEntryBuffer."Entry Type"::"Unrealized Gain",            DetailedCVLedgEntryBuffer."Entry Type"::"Realized Loss",            DetailedCVLedgEntryBuffer."Entry Type"::"Realized Gain":                begin                    IsHandled := false;                    OnPostDtldCVLedgEntryOnBeforeCreateGLEntryGainLoss(GenJournalLine, DetailedCVLedgEntryBuffer, Unapply, AccNo, IsHandled, AdjAmount, AddCurrencyCode, MultiplePostingGroups);                    if IsApplicableCurrencyCodeNeeded(GenJournalLine."Currency Code") then                        SetApplyingCurrencyCode(DetailedCVLedgEntryBuffer."Currency Code");                    if not IsHandled then                        CreateGLEntryGainLoss(GenJournalLine, AccNo, -DetailedCVLedgEntryBuffer."Amount (LCY)", DetailedCVLedgEntryBuffer."Currency Code" = AddCurrencyCode);                    SetApplyingCurrencyCode('');                    if MultiplePostingGroups and (DetailedCVLedgEntryBuffer."Entry Type" in [DetailedCVLedgEntryBuffer."Entry Type"::"Unrealized Loss", DetailedCVLedgEntryBuffer."Entry Type"::"Unrealized Gain"]) then begin                        case GenJournalLine."Account Type" of                            GenJournalLine."Account Type"::Customer:                                begin                                    GetCustomerPostingGroup(GenJournalLine, CustomerPostingGroup);                                    AccNo2 := GetCustDtldCVLedgEntryBufferAccNo(GenJournalLine, DetailedCVLedgEntryBuffer);                                    AccNo3 := GetCustomerReceivablesAccount(GenJournalLine, CustomerPostingGroup);                                end;                            GenJournalLine."Account Type"::Employee:                                begin                                    EmployeePostingGroup.Get(GenJournalLine."Posting Group");                                    AccNo2 := GetEmplDtldCVLedgEntryBufferAccNo(GenJournalLine, DetailedCVLedgEntryBuffer);                                    AccNo3 := GetEmployeePayablesAccount(GenJournalLine, EmployeePostingGroup);                                end;                        end;                        if AccNo2 <> AccNo3 then begin                            CreateGLEntryGainLoss(GenJournalLine, AccNo2, DetailedCVLedgEntryBuffer."Amount (LCY)", DetailedCVLedgEntryBuffer."Currency Code" = AddCurrencyCode);                            CreateGLEntryGainLoss(GenJournalLine, AccNo3, -DetailedCVLedgEntryBuffer."Amount (LCY)", DetailedCVLedgEntryBuffer."Currency Code" = AddCurrencyCode);                        end;                    end;                    if not Unapply then                        CollectAdjustment(AdjAmount, -DetailedCVLedgEntryBuffer."Amount (LCY)", 0);                end;            DetailedCVLedgEntryBuffer."Entry Type"::"Payment Discount",            DetailedCVLedgEntryBuffer."Entry Type"::"Payment Tolerance",            DetailedCVLedgEntryBuffer."Entry Type"::"Payment Discount Tolerance":                begin                    PostDtldCVLedgEntryCreateGLEntryPmtDiscTol(GenJournalLine, DetailedCVLedgEntryBuffer, AccNo, Unapply);                    if not Unapply then                        CollectAdjustment(AdjAmount, -DetailedCVLedgEntryBuffer."Amount (LCY)", -DetailedCVLedgEntryBuffer."Additional-Currency Amount");                end;            DetailedCVLedgEntryBuffer."Entry Type"::"Payment Discount (VAT Excl.)",            DetailedCVLedgEntryBuffer."Entry Type"::"Payment Tolerance (VAT Excl.)",            DetailedCVLedgEntryBuffer."Entry Type"::"Payment Discount Tolerance (VAT Excl.)":                begin                    if not Unapply then                        CreateGLEntryVATCollectAdj(                          GenJournalLine, AccNo, -DetailedCVLedgEntryBuffer."Amount (LCY)", -DetailedCVLedgEntryBuffer."Additional-Currency Amount", -DetailedCVLedgEntryBuffer."VAT Amount (LCY)", DetailedCVLedgEntryBuffer,                          AdjAmount)                    else                        CreateGLEntryVAT(                          GenJournalLine, AccNo, -DetailedCVLedgEntryBuffer."Amount (LCY)", -DetailedCVLedgEntryBuffer."Additional-Currency Amount", -DetailedCVLedgEntryBuffer."VAT Amount (LCY)", DetailedCVLedgEntryBuffer);                    OnPostDtldCVLedgEntryOnAfterCreateGLEntryPmtDiscTolVATExcl(DetailedCVLedgEntryBuffer, TempGLEntryBuf);                end;            DetailedCVLedgEntryBuffer."Entry Type"::"Appln. Rounding":                if DetailedCVLedgEntryBuffer."Amount (LCY)" <> 0 then begin                    CreateGLEntry(                        GenJournalLine, AccNo, -DetailedCVLedgEntryBuffer."Amount (LCY)", -DetailedCVLedgEntryBuffer."Additional-Currency Amount", true,                        CalcAmountSrcCurr(GenJournalLine, -DetailedCVLedgEntryBuffer."Amount (LCY)"));                    if not Unapply then                        CollectAdjustment(AdjAmount, -DetailedCVLedgEntryBuffer."Amount (LCY)", -DetailedCVLedgEntryBuffer."Additional-Currency Amount");                end;            DetailedCVLedgEntryBuffer."Entry Type"::"Correction of Remaining Amount":                if DetailedCVLedgEntryBuffer."Amount (LCY)" <> 0 then begin                    CreateGLEntry(                        GenJournalLine, AccNo, -DetailedCVLedgEntryBuffer."Amount (LCY)", 0, false,                        CalcAmountSrcCurr(GenJournalLine, -DetailedCVLedgEntryBuffer."Amount (LCY)"));                    if not Unapply then                        CollectAdjustment(AdjAmount, -DetailedCVLedgEntryBuffer."Amount (LCY)", 0);                end;            DetailedCVLedgEntryBuffer."Entry Type"::"Payment Discount (VAT Adjustment)",                DetailedCVLedgEntryBuffer."Entry Type"::"Payment Tolerance (VAT Adjustment)",                DetailedCVLedgEntryBuffer."Entry Type"::"Payment Discount Tolerance (VAT Adjustment)":                ;            else                DetailedCVLedgEntryBuffer.FieldError(DetailedCVLedgEntryBuffer."Entry Type");        end;        OnAfterPostDtldCVLedgEntry(            GenJournalLine, DetailedCVLedgEntryBuffer, Unapply, AccNo,            AdjAmount, NextEntryNo, AddCurrencyCode, MultiplePostingGroups);    end;    local procedure PostDtldCVLedgEntryCreateGLEntryPmtDiscTol(var GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var AccNo: Code[20]; var Unapply: Boolean)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostDtldCVLedgEntryCreateGLEntryPmtDiscTol(GenJnlLine, DtldCVLedgEntryBuf, Unapply, AccNo, IsHandled);        if IsHandled then            exit;        CreateGLEntry(            GenJnlLine, AccNo, -DtldCVLedgEntryBuf."Amount (LCY)", -DtldCVLedgEntryBuf."Additional-Currency Amount", false,            CalcAmountSrcCurr(GenJnlLine, -DtldCVLedgEntryBuf."Amount (LCY)"));        OnPostDtldCVLedgEntryOnAfterCreateGLEntryPmtDiscTol(DtldCVLedgEntryBuf, TempGLEntryBuf);    end;    local procedure PostDtldCustVATAdjustment(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; OriginalTransactionNo: Integer)    var        VATPostingSetup: Record "VAT Posting Setup";        TaxJurisdiction: Record "Tax Jurisdiction";    begin        DtldCVLedgEntryBuf.FindVATEntry(VATEntry, OriginalTransactionNo);        OnPostDtldCustVATAdjustmentOnAfterFindVATEntry(GenJnlLine, DtldCVLedgEntryBuf);        case VATPostingSetup."VAT Calculation Type" of            VATPostingSetup."VAT Calculation Type"::"Normal VAT",            VATPostingSetup."VAT Calculation Type"::"Full VAT":                begin                    VATPostingSetup.Get(DtldCVLedgEntryBuf."VAT Bus. Posting Group", DtldCVLedgEntryBuf."VAT Prod. Posting Group");                    VATPostingSetup.TestField("VAT Calculation Type", VATEntry."VAT Calculation Type");                    CreateGLEntry(                        GenJnlLine, VATPostingSetup.GetSalesAccount(false), -DtldCVLedgEntryBuf."Amount (LCY)", -DtldCVLedgEntryBuf."Additional-Currency Amount", false,                        CalcAmountSrcCurr(GenJnlLine, -DtldCVLedgEntryBuf."Amount (LCY)"));                end;            VATPostingSetup."VAT Calculation Type"::"Reverse Charge VAT":                ;            VATPostingSetup."VAT Calculation Type"::"Sales Tax":                begin                    DtldCVLedgEntryBuf.TestField("Tax Jurisdiction Code");                    TaxJurisdiction.Get(DtldCVLedgEntryBuf."Tax Jurisdiction Code");                    CreateGLEntry(                        GenJnlLine, TaxJurisdiction.GetPurchAccount(false), -DtldCVLedgEntryBuf."Amount (LCY)", -DtldCVLedgEntryBuf."Additional-Currency Amount", false,                        CalcAmountSrcCurr(GenJnlLine, -DtldCVLedgEntryBuf."Amount (LCY)"));                end;        end;        OnAfterPostDtldCustVATAdjustment(GenJnlLine, DtldCVLedgEntryBuf);    end;    local procedure PostDtldVendVATAdjustment(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; OriginalTransactionNo: Integer)    var        VATPostingSetup: Record "VAT Posting Setup";        TaxJurisdiction: Record "Tax Jurisdiction";        IsHandled: Boolean;    begin        DtldCVLedgEntryBuf.FindVATEntry(VATEntry, OriginalTransactionNo);        OnPostDtldVendVATAdjustmentOnAfterFindVATEntry(DtldCVLedgEntryBuf, VATEntry);        case VATPostingSetup."VAT Calculation Type" of            VATPostingSetup."VAT Calculation Type"::"Normal VAT",            VATPostingSetup."VAT Calculation Type"::"Full VAT":                begin                    VATPostingSetup.Get(DtldCVLedgEntryBuf."VAT Bus. Posting Group", DtldCVLedgEntryBuf."VAT Prod. Posting Group");                    VATPostingSetup.TestField("VAT Calculation Type", VATEntry."VAT Calculation Type");                    IsHandled := false;                    OnPostDtldVendVATAdjustmentOnBeforeCreateGLEntryForNormalOrFullVAT(DtldCVLedgEntryBuf, VATEntry, GenJnlLine, IsHandled);                    if not IsHandled then                        CreateGLEntry(                            GenJnlLine, VATPostingSetup.GetPurchAccount(false), -DtldCVLedgEntryBuf."Amount (LCY)", -DtldCVLedgEntryBuf."Additional-Currency Amount", false,                            CalcAmountSrcCurr(GenJnlLine, -DtldCVLedgEntryBuf."Amount (LCY)"));                end;            VATPostingSetup."VAT Calculation Type"::"Reverse Charge VAT":                begin                    VATPostingSetup.Get(DtldCVLedgEntryBuf."VAT Bus. Posting Group", DtldCVLedgEntryBuf."VAT Prod. Posting Group");                    VATPostingSetup.TestField("VAT Calculation Type", VATEntry."VAT Calculation Type");                    IsHandled := false;                    OnPostDtldVendVATAdjustmentOnBeforeCreateGLEntryReverseChargeVATInPostDtldVendVATAdjustment(DtldCVLedgEntryBuf, VATEntry, GenJnlLine, IsHandled);                    if not IsHandled then begin                        CreateGLEntry(                            GenJnlLine, VATPostingSetup.GetPurchAccount(false), -DtldCVLedgEntryBuf."Amount (LCY)", -DtldCVLedgEntryBuf."Additional-Currency Amount", false,                            CalcAmountSrcCurr(GenJnlLine, -DtldCVLedgEntryBuf."Amount (LCY)"));                        CreateGLEntry(                            GenJnlLine, VATPostingSetup.GetRevChargeAccount(false), DtldCVLedgEntryBuf."Amount (LCY)", DtldCVLedgEntryBuf."Additional-Currency Amount", false,                            CalcAmountSrcCurr(GenJnlLine, DtldCVLedgEntryBuf."Amount (LCY)"));                    end;                end;            VATPostingSetup."VAT Calculation Type"::"Sales Tax":                begin                    TaxJurisdiction.Get(DtldCVLedgEntryBuf."Tax Jurisdiction Code");                    IsHandled := false;                    OnPostDtldVendVATAdjustmentOnBeforeCreateGLEntrySalesTaxInPostDtldVendVATAdjustment(DtldCVLedgEntryBuf, VATEntry, GenJnlLine, IsHandled);                    if not isHandled then                        if DtldCVLedgEntryBuf."Use Tax" then begin                            CreateGLEntry(                                GenJnlLine, TaxJurisdiction.GetPurchAccount(false), -DtldCVLedgEntryBuf."Amount (LCY)", -DtldCVLedgEntryBuf."Additional-Currency Amount", false,                                CalcAmountSrcCurr(GenJnlLine, -DtldCVLedgEntryBuf."Amount (LCY)"));                            CreateGLEntry(                                GenJnlLine, TaxJurisdiction.GetRevChargeAccount(false), DtldCVLedgEntryBuf."Amount (LCY)", DtldCVLedgEntryBuf."Additional-Currency Amount", false,                                CalcAmountSrcCurr(GenJnlLine, DtldCVLedgEntryBuf."Amount (LCY)"));                        end else                            CreateGLEntry(                                GenJnlLine, TaxJurisdiction.GetPurchAccount(false), -DtldCVLedgEntryBuf."Amount (LCY)", -DtldCVLedgEntryBuf."Additional-Currency Amount", false,                                CalcAmountSrcCurr(GenJnlLine, -DtldCVLedgEntryBuf."Amount (LCY)"));                end;        end;        OnAfterPostDtldVendVATAdjustment(GenJnlLine, VATPostingSetup, DtldCVLedgEntryBuf, VATEntry);    end;    internal procedure VendUnrealizedVAT(GenJnlLine: Record "Gen. Journal Line"; var VendLedgEntry2: Record "Vendor Ledger Entry"; SettledAmount: Decimal)    var        VATEntry2: Record "VAT Entry";        VATPostingSetup: Record "VAT Posting Setup";        VATPart: Decimal;        VATAmount: Decimal;        VATBase: Decimal;        VATAmountAddCurr: Decimal;        VATBaseAddCurr: Decimal;        PaidAmount: Decimal;        TotalUnrealVATAmountFirst: Decimal;        TotalUnrealVATAmountLast: Decimal;        PurchVATAccount: Code[20];        PurchVATUnrealAccount: Code[20];        PurchReverseAccount: Code[20];        PurchReverseUnrealAccount: Code[20];        LastConnectionNo: Integer;        GLEntryNo: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeVendUnrealizedVAT(GenJnlLine, VendLedgEntry2, SettledAmount, IsHandled);        if IsHandled then            exit;        VATEntry2.ReadIsolation := IsolationLevel::ReadUncommitted;        VATEntry2.Reset();        VATEntry2.SetCurrentKey("Transaction No.");        VATEntry2.SetRange("Transaction No.", VendLedgEntry2."Transaction No.");        OnVendUnrealizedVATOnAfterSetFilterForVATEntry2(VATEntry2);        PaidAmount := -VendLedgEntry2."Amount (LCY)" + VendLedgEntry2."Remaining Amt. (LCY)";        OnVendUnrealizedVATOnAfterCalcPaidAmount(GenJnlLine, VendLedgEntry2, SettledAmount, PaidAmount);        if VATEntry2.FindSet() then            repeat                VATPostingSetup.Get(VATEntry2."VAT Bus. Posting Group", VATEntry2."VAT Prod. Posting Group");                if VATPostingSetup."Unrealized VAT Type" in                   [VATPostingSetup."Unrealized VAT Type"::Last, VATPostingSetup."Unrealized VAT Type"::"Last (Fully Paid)"]                then                    TotalUnrealVATAmountLast := TotalUnrealVATAmountLast - VATEntry2."Remaining Unrealized Amount";                if VATPostingSetup."Unrealized VAT Type" in                   [VATPostingSetup."Unrealized VAT Type"::First, VATPostingSetup."Unrealized VAT Type"::"First (Fully Paid)"]                then                    TotalUnrealVATAmountFirst := TotalUnrealVATAmountFirst - VATEntry2."Remaining Unrealized Amount";            until VATEntry2.Next() = 0;        OnVendUnrealizedVATOnAfterCalcTotalUnrealVATAmount(VATEntry2, TotalUnrealVATAmountFirst, TotalUnrealVATAmountLast);        if VATEntry2.FindSet() then begin            LastConnectionNo := 0;            repeat                VATPostingSetup.Get(VATEntry2."VAT Bus. Posting Group", VATEntry2."VAT Prod. Posting Group");                if LastConnectionNo <> VATEntry2."Sales Tax Connection No." then begin                    InsertSummarizedVAT(GenJnlLine);                    LastConnectionNo := VATEntry2."Sales Tax Connection No.";                end;                IsHandled := false;                OnVendUnrealizedVATOnBeforeGetUnrealizedVATPart(GenJnlLine, VendLedgEntry2, PaidAmount, TotalUnrealVATAmountFirst, TotalUnrealVATAmountLast, SettledAmount, VATEntry2, VATPart, IsHandled);                if not IsHandled then                    VATPart :=                      VATEntry2.GetUnrealizedVATPart(                        Round(SettledAmount / VendLedgEntry2.GetAdjustedCurrencyFactor()),                        PaidAmount,                        VendLedgEntry2."Amount (LCY)",                        TotalUnrealVATAmountFirst,                        TotalUnrealVATAmountLast);                OnVendUnrealizedVATOnAfterVATPartCalculation(                  GenJnlLine, VendLedgEntry2, PaidAmount, TotalUnrealVATAmountFirst, TotalUnrealVATAmountLast, SettledAmount, VATEntry2);                if VATPart > 0 then begin                    GetVendUnrealizedVATAccounts(VATEntry2, VATPostingSetup, PurchVATAccount, PurchVATUnrealAccount, PurchReverseAccount, PurchReverseUnrealAccount);                    if VATPart = 1 then begin                        VATAmount := VATEntry2."Remaining Unrealized Amount";                        VATBase := VATEntry2."Remaining Unrealized Base";                        VATAmountAddCurr := VATEntry2."Add.-Curr. Rem. Unreal. Amount";                        VATBaseAddCurr := VATEntry2."Add.-Curr. Rem. Unreal. Base";                    end else begin                        VATAmount := Round(VATEntry2."Remaining Unrealized Amount" * VATPart, GLSetup."Amount Rounding Precision");                        VATBase := Round(VATEntry2."Remaining Unrealized Base" * VATPart, GLSetup."Amount Rounding Precision");                        VATAmountAddCurr :=                          Round(                            VATEntry2."Add.-Curr. Rem. Unreal. Amount" * VATPart,                            AddCurrency."Amount Rounding Precision");                        VATBaseAddCurr :=                          Round(                            VATEntry2."Add.-Curr. Rem. Unreal. Base" * VATPart,                            AddCurrency."Amount Rounding Precision");                    end;                    OnVendUnrealizedVATOnBeforeInitGLEntryVAT(GenJnlLine, VATEntry2, VATAmount, VATBase, VATAmountAddCurr, VATBaseAddCurr, VendLedgEntry2, SettledAmount);                    if (VATEntry2."VAT Calculation Type" = VATEntry2."VAT Calculation Type"::"Sales Tax") and                       (VATEntry2.Type = VATEntry2.Type::Purchase) and VATEntry2."Use Tax"                    then begin                        InitGLEntryVAT(                          GenJnlLine, PurchReverseUnrealAccount, PurchReverseAccount, -VATAmount, -VATAmountAddCurr, false);                        GLEntryNo :=                          InitGLEntryVATCopy(                            GenJnlLine, PurchReverseAccount, PurchReverseUnrealAccount, VATAmount, VATAmountAddCurr, VATEntry2);                    end else begin                        IsHandled := false;                        OnBeforeInitGLEntryVATOnVendUnrealizedVAT(VATEntry2, GenJnlLine, NextEntryNo, IsHandled);                        if not IsHandled then begin                            InitGLEntryVAT(                              GenJnlLine, PurchVATUnrealAccount, PurchVATAccount, -VATAmount, -VATAmountAddCurr, false);                            GLEntryNo :=                              InitGLEntryVATCopy(GenJnlLine, PurchVATAccount, PurchVATUnrealAccount, VATAmount, VATAmountAddCurr, VATEntry2);                        end;                    end;                    IsHandled := false;                    OnBeforeInitGLEntryVATOnVendUnrealizedVATForRevChargeVAT(VATEntry2, GenJnlLine, NextEntryNo, IsHandled);                    if not IsHandled then                        if VATEntry2."VAT Calculation Type" = VATEntry2."VAT Calculation Type"::"Reverse Charge VAT" then begin                            InitGLEntryVAT(                                GenJnlLine, PurchReverseUnrealAccount, PurchReverseAccount, VATAmount, VATAmountAddCurr, false);                            GLEntryNo :=                                InitGLEntryVATCopy(GenJnlLine, PurchReverseAccount, PurchReverseUnrealAccount, -VATAmount, -VATAmountAddCurr, VATEntry2);                        end;                    OnVendUnrealizedVATOnBeforePostUnrealVATEntry(GenJnlLine, VATEntry2, VATAmount, VATBase, VATAmountAddCurr, VATBaseAddCurr, GLEntryNo, VATPart);                    PostUnrealVATEntry(GenJnlLine, VATEntry2, VATAmount, VATBase, VATAmountAddCurr, VATBaseAddCurr, GLEntryNo);                end;            until VATEntry2.Next() = 0;            InsertSummarizedVAT(GenJnlLine);        end;    end;    local procedure GetVendUnrealizedVATAccounts(var VATEntry2: Record "VAT Entry"; VATPostingSetup: Record "VAT Posting Setup"; var PurchVATAccount: Code[20]; var PurchVATUnrealAccount: Code[20]; var PurchReverseAccount: Code[20]; var PurchReverseUnrealAccount: Code[20])    var        TaxJurisdiction: Record "Tax Jurisdiction";    begin        case VATEntry2."VAT Calculation Type" of            VATEntry2."VAT Calculation Type"::"Normal VAT",            VATEntry2."VAT Calculation Type"::"Full VAT":                begin                    PurchVATAccount := VATPostingSetup.GetPurchAccount(false);                    PurchVATUnrealAccount := VATPostingSetup.GetPurchAccount(true);                end;            VATEntry2."VAT Calculation Type"::"Reverse Charge VAT":                begin                    PurchVATAccount := VATPostingSetup.GetPurchAccount(false);                    PurchVATUnrealAccount := VATPostingSetup.GetPurchAccount(true);                    PurchReverseAccount := VATPostingSetup.GetRevChargeAccount(false);                    PurchReverseUnrealAccount := VATPostingSetup.GetRevChargeAccount(true);                end;            VATEntry2."VAT Calculation Type"::"Sales Tax":                if (VATEntry2.Type = VATEntry2.Type::Purchase) and VATEntry2."Use Tax" then begin                    TaxJurisdiction.Get(VATEntry2."Tax Jurisdiction Code");                    PurchVATAccount := TaxJurisdiction.GetPurchAccount(false);                    PurchVATUnrealAccount := TaxJurisdiction.GetPurchAccount(true);                    PurchReverseAccount := TaxJurisdiction.GetRevChargeAccount(false);                    PurchReverseUnrealAccount := TaxJurisdiction.GetRevChargeAccount(true);                end else begin                    TaxJurisdiction.Get(VATEntry2."Tax Jurisdiction Code");                    PurchVATAccount := TaxJurisdiction.GetPurchAccount(false);                    PurchVATUnrealAccount := TaxJurisdiction.GetPurchAccount(true);                end;        end;        OnAfterGetVendUnrealizedVATAccounts(VATEntry2, VATPostingSetup, PurchVATAccount, PurchVATUnrealAccount, PurchReverseAccount, PurchReverseUnrealAccount);    end;    /// <summary>    /// Posts an unrealized VAT entry for general journal line processing.    /// Handles unrealized VAT scenarios where VAT is posted upon payment rather than invoice.    /// </summary>    /// <param name="GenJnlLine">General journal line being processed</param>    /// <param name="VATEntry2">Source VAT entry to base the unrealized entry on</param>    /// <param name="VATAmount">VAT amount in local currency</param>    /// <param name="VATBase">VAT base amount in local currency</param>    /// <param name="VATAmountAddCurr">VAT amount in additional currency</param>    /// <param name="VATBaseAddCurr">VAT base amount in additional currency</param>    /// <param name="GLEntryNo">Associated G/L entry number for cross-reference</param>    procedure PostUnrealVATEntry(GenJnlLine: Record "Gen. Journal Line"; var VATEntry2: Record "VAT Entry"; VATAmount: Decimal; VATBase: Decimal; VATAmountAddCurr: Decimal; VATBaseAddCurr: Decimal; GLEntryNo: Integer)    begin        OnBeforePostUnrealVATEntry(GenJnlLine, VATEntry);        VATEntry.LockTable();        VATEntry := VATEntry2;        VATEntry."Entry No." := NextVATEntryNo;        VATEntry.CopyPostingDataFromGenJnlLine(GenJnlLine);        VATEntry.SetVATDateFromGenJnlLine(GenJnlLine);        VATEntry.Amount := VATAmount;        VATEntry.Base := VATBase;        VATEntry."Additional-Currency Amount" := VATAmountAddCurr;        VATEntry."Additional-Currency Base" := VATBaseAddCurr;        VATEntry.SetUnrealAmountsToZero();        VATEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(VATEntry."User ID"));        VATEntry."Closed by Entry No." := 0;        VATEntry.Closed := false;        VATEntry."Transaction No." := NextTransactionNo;        VATEntry."Sales Tax Connection No." := NextConnectionNo;        VATEntry."Unrealized VAT Entry No." := VATEntry2."Entry No.";        VATEntry."Base Before Pmt. Disc." := VATEntry.Base;        VATEntry."G/L Acc. No." := '';        VATEntry."G/L Register No." := GLReg."No.";        VATEntry.TestField("G/L Register No.");        OnBeforeInsertPostUnrealVATEntry(VATEntry, GenJnlLine, VATEntry2);        VATEntry.Insert(true);        OnPostUnrealVATEntryOnBeforeInsertLinkSelf(TempGLEntryVATEntryLink, VATEntry, GLEntryNo, NextVATEntryNo);        TempGLEntryVATEntryLink.InsertLinkSelf(GLEntryNo + 1, NextVATEntryNo);        NextVATEntryNo := NextVATEntryNo + 1;        VATEntry2."Remaining Unrealized Amount" :=          VATEntry2."Remaining Unrealized Amount" - VATEntry.Amount;        VATEntry2."Remaining Unrealized Base" :=          VATEntry2."Remaining Unrealized Base" - VATEntry.Base;        VATEntry2."Add.-Curr. Rem. Unreal. Amount" :=          VATEntry2."Add.-Curr. Rem. Unreal. Amount" - VATEntry."Additional-Currency Amount";        VATEntry2."Add.-Curr. Rem. Unreal. Base" :=          VATEntry2."Add.-Curr. Rem. Unreal. Base" - VATEntry."Additional-Currency Base";        VATEntry2.Modify();        OnAfterPostUnrealVATEntry(GenJnlLine, VATEntry2, VATAmount, VATBase, GLEntryNo, NextEntryNo, NextVATEntryNo);    end;    /// <summary>    /// Posts application entry to and applies it to the already existing customer/vendor/employee ledger entry.    /// In the process g/l entries and detailed entries are created, existing customer/vendor/employee ledger entries are updated.    /// </summary>    /// <param name="GenJnlLine">Gen. journal line that is being posted.</param>    /// <param name="DtldCVLedgEntryBuf">Detailed ledger entries that has to be created to perform the application.</param>    /// <param name="OldCVLedgEntryBuf">Customer/vendor/employee ledger entrie that the application is made to.</param>    /// <param name="NewCVLedgEntryBuf">New customer/vendor/employee ledger entry that might have been adjusted through events.</param>    /// <param name="NewCVLedgEntryBuf2">Original new customer/vendor/employee ledger entry.</param>    /// <param name="BlockPaymentTolerance">Flag is payment tolerance should be checked.</param>    /// <param name="AllApplied">Flag that determines if more applications can be made.</param>    /// <param name="AppliedAmount">Amount that should be used for the application.</param>    /// <param name="PmtTolAmtToBeApplied">Payment tolerance amount to be applied.</param>    procedure PostApply(var GenJnlLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; BlockPaymentTolerance: Boolean; AllApplied: Boolean; var AppliedAmount: Decimal; var PmtTolAmtToBeApplied: Decimal)    var        OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer";        OldCVLedgEntryBuf3: Record "CV Ledger Entry Buffer";        OldRemainingAmtBeforeAppln: Decimal;        ApplnRoundingPrecision: Decimal;        AppliedAmountLCY: Decimal;        OldAppliedAmount: Decimal;        IsHandled: Boolean;    begin        OnBeforePostApply(GenJnlLine, DtldCVLedgEntryBuf, OldCVLedgEntryBuf, NewCVLedgEntryBuf, NewCVLedgEntryBuf2);        OldRemainingAmtBeforeAppln := OldCVLedgEntryBuf."Remaining Amount";        OldCVLedgEntryBuf3 := OldCVLedgEntryBuf;        // Management of posting in multiple currencies        OldCVLedgEntryBuf2 := OldCVLedgEntryBuf;        OldCVLedgEntryBuf.CopyFilter(Positive, OldCVLedgEntryBuf2.Positive);        ApplnRoundingPrecision := GetApplnRoundPrecision(NewCVLedgEntryBuf, OldCVLedgEntryBuf);        OldCVLedgEntryBuf2.RecalculateAmounts(          OldCVLedgEntryBuf2."Currency Code", NewCVLedgEntryBuf."Currency Code", NewCVLedgEntryBuf."Posting Date");        OnPostApplyOnAfterRecalculateAmounts(            OldCVLedgEntryBuf2, OldCVLedgEntryBuf, NewCVLedgEntryBuf, GenJnlLine, DtldCVLedgEntryBuf, AddCurrencyCode, NextTransactionNo, NextVATEntryNo);        if not BlockPaymentTolerance then            CalcPmtTolerance(              NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine,              PmtTolAmtToBeApplied, NextTransactionNo, FirstNewVATEntryNo);        CalcPmtDisc(          NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine,          PmtTolAmtToBeApplied, ApplnRoundingPrecision, NextTransactionNo, FirstNewVATEntryNo);        if not BlockPaymentTolerance then            CalcPmtDiscTolerance(              NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine,              NextTransactionNo, FirstNewVATEntryNo);        IsHandled := false;        OnBeforeCalcCurrencyApplnRounding(          GenJnlLine, DtldCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, OldCVLedgEntryBuf3,          NewCVLedgEntryBuf, NewCVLedgEntryBuf2, IsHandled);        if not IsHandled then            CalcCurrencyApplnRounding(              NewCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, GenJnlLine, ApplnRoundingPrecision);        IsHandled := false;        OnPostApplyOnAfterCalcCurrencyApplnRounding(GenJnlLine, NewCVLedgEntryBuf, NewCVLedgEntryBuf2, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, DtldCVLedgEntryBuf, AppliedAmount, PmtTolAmtToBeApplied, IsHandled);        if not IsHandled then begin            FindAmtForAppln(              NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2,              AppliedAmount, AppliedAmountLCY, OldAppliedAmount, ApplnRoundingPrecision, GenJnlLine);            OnPostApplyOnAfterFindAmtForApplnOnBeforeCalcCurrencyUnrealizedGainLoss(              NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, AppliedAmount,              AppliedAmountLCY, OldAppliedAmount, AmountRoundingPrecision, VATEntry);            CalcCurrencyUnrealizedGainLoss(              OldCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine, -OldAppliedAmount, OldRemainingAmtBeforeAppln);            CalcCurrencyRealizedGainLoss(              NewCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine, AppliedAmount, AppliedAmountLCY);            CalcCurrencyRealizedGainLoss(              OldCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine, -OldAppliedAmount, -AppliedAmountLCY);            CalcApplication(              NewCVLedgEntryBuf, OldCVLedgEntryBuf, DtldCVLedgEntryBuf,              GenJnlLine, AppliedAmount, AppliedAmountLCY, OldAppliedAmount,              NewCVLedgEntryBuf2, OldCVLedgEntryBuf3, AllApplied);            PaymentToleranceMgt.CalcRemainingPmtDisc(NewCVLedgEntryBuf, OldCVLedgEntryBuf, OldCVLedgEntryBuf2, GLSetup);            CalcAmtLCYAdjustment(OldCVLedgEntryBuf, DtldCVLedgEntryBuf, GenJnlLine);        end;        OnAfterPostApply(GenJnlLine, DtldCVLedgEntryBuf, OldCVLedgEntryBuf, NewCVLedgEntryBuf, NewCVLedgEntryBuf2);    end;    /// <summary>    /// Creates and posts un-applying entry for currently applied detailed customer ledger entry.    /// G/l entry with unapplied amount is created as part of the process    /// Related customer ledger entry is being updated as part of the process    /// Unrealized vat is posted    /// </summary>    /// <remarks>    /// Customer, detailed customer ledger and vat entries are being locked    /// </remarks>    /// <param name="GenJournalLine">Gen. journal line being posted.</param>    /// <param name="DetailedCustLedgEntry">Detailed ledger entry that is currently applied</param>    procedure UnapplyCustLedgEntry(GenJournalLine: Record "Gen. Journal Line"; DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    var        Customer: Record Customer;        CustomerPostingGroup: Record "Customer Posting Group";        GenJournalLineToPost: Record "Gen. Journal Line";        DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry";        NewDetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry";        CustLedgerEntry: Record "Cust. Ledger Entry";        DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer";        VATEntry: Record "VAT Entry";        TempVATEntry2: Record "VAT Entry" temporary;        CurrencyLCY: Record Currency;        TempDimensionPostingBuffer: Record "Dimension Posting Buffer" temporary;        AdjAmount: array[4] of Decimal;        NextDtldLedgEntryNo: Integer;        UnapplyVATEntries: Boolean;        PmtDiscTolExists: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUnapplyCustLedgEntry(GenJournalLine, DetailedCustLedgEntry, IsHandled);        if IsHandled then            exit;        GenJournalLineToPost.TransferFields(GenJournalLine);        if GenJournalLineToPost."Document Date" = 0D then            GenJournalLineToPost."Document Date" := GenJournalLineToPost."Posting Date";        AmountRoundingPrecision := GetSourceCurrency(GenJournalLine."Source Currency Code");        if NextEntryNo = 0 then            StartPosting(GenJournalLineToPost)        else            ContinuePosting(GenJournalLineToPost);        ReadGLSetup(GLSetup);        Customer.Get(DetailedCustLedgEntry."Customer No.");        Customer.CheckBlockedCustOnJnls(Customer, GenJournalLine."Document Type"::Payment, true);        OnUnapplyCustLedgEntryOnBeforeCheckPostingGroup(GenJournalLineToPost, Customer);        CustomerPostingGroup.Get(GenJournalLineToPost."Posting Group");        GetCustomerReceivablesAccount(GenJournalLineToPost, CustomerPostingGroup);        VATEntry.LockTable();        DetailedCustLedgEntry.LockTable();        CustLedgerEntry.LockTable();        DetailedCustLedgEntry.TestField("Entry Type", DetailedCustLedgEntry."Entry Type"::Application);        DetailedCustLedgEntry2.Reset();        DetailedCustLedgEntry2.FindLast();        NextDtldLedgEntryNo := DetailedCustLedgEntry2."Entry No." + 1;        OnUnapplyCustLedgEntryOnAfterGetNextDtldLedgEntryNo(GenJournalLine);        if DetailedCustLedgEntry."Transaction No." = 0 then begin            DetailedCustLedgEntry2.SetCurrentKey("Application No.", "Customer No.", "Entry Type");            DetailedCustLedgEntry2.SetRange("Application No.", DetailedCustLedgEntry."Application No.");        end else begin            DetailedCustLedgEntry2.SetCurrentKey("Transaction No.", "Customer No.", "Entry Type");            DetailedCustLedgEntry2.SetRange("Transaction No.", DetailedCustLedgEntry."Transaction No.");        end;        DetailedCustLedgEntry2.SetRange("Customer No.", DetailedCustLedgEntry."Customer No.");        MultiplePostingGroups := CheckDetCustLedgEntryMultiplePostingGrOnBeforeUnapply(DetailedCustLedgEntry2, DetailedCustLedgEntry);        DetailedCustLedgEntry2.SetFilter("Entry Type", '>%1', DetailedCustLedgEntry."Entry Type"::"Initial Entry");        OnUnapplyCustLedgEntryOnAfterDtldCustLedgEntrySetFilters(DetailedCustLedgEntry2, DetailedCustLedgEntry);        if DetailedCustLedgEntry."Transaction No." <> 0 then begin            UnapplyVATEntries := false;            DetailedCustLedgEntry2.FindSet();            repeat                DetailedCustLedgEntry2.TestField(Unapplied, false);                if IsVATAdjustment(DetailedCustLedgEntry2."Entry Type") then                    UnapplyVATEntries := true;                if not GLSetup."Pmt. Disc. Excl. VAT" and GLSetup."Adjust for Payment Disc." then                    if IsVATExcluded(DetailedCustLedgEntry2."Entry Type") then                        UnapplyVATEntries := true;                if DetailedCustLedgEntry2."Entry Type" = DetailedCustLedgEntry2."Entry Type"::"Payment Discount Tolerance (VAT Excl.)" then                    PmtDiscTolExists := true;            until DetailedCustLedgEntry2.Next() = 0;            OnUnapplyCustLedgEntryOnBeforePostUnapply(DetailedCustLedgEntry, DetailedCustLedgEntry2);            PostUnapply(              GenJournalLineToPost, VATEntry, VATEntry.Type::Sale,              DetailedCustLedgEntry."Customer No.", DetailedCustLedgEntry."Transaction No.", UnapplyVATEntries, TempVATEntry);            OnUnapplyCustLedgEntryOnAfterPostUnapply(GenJournalLineToPost, DetailedCustLedgEntry, DetailedCustLedgEntry2);            if PmtDiscTolExists then                ProcessTempVATEntryCust(DetailedCustLedgEntry2, TempVATEntry)            else begin                DetailedCustLedgEntry2.SetRange("Entry Type", DetailedCustLedgEntry2."Entry Type"::"Payment Tolerance (VAT Excl.)");                ProcessTempVATEntryCust(DetailedCustLedgEntry2, TempVATEntry);                DetailedCustLedgEntry2.SetRange("Entry Type", DetailedCustLedgEntry2."Entry Type"::"Payment Discount (VAT Excl.)");                ProcessTempVATEntryCust(DetailedCustLedgEntry2, TempVATEntry);                DetailedCustLedgEntry2.SetFilter("Entry Type", '>%1', DetailedCustLedgEntry."Entry Type"::"Initial Entry");            end;        end;        // Look one more time        if DetailedCustLedgEntry."Transaction No." = 0 then            DetailedCustLedgEntry2.SetCurrentKey("Application No.", "Customer No.", "Entry Type")        else            DetailedCustLedgEntry2.SetCurrentKey("Transaction No.", "Customer No.", "Entry Type");        OnOnUnapplyCustLedgEntryOnBeforeSecondLook(DetailedCustLedgEntry2, NextDtldLedgEntryNo);        DetailedCustLedgEntry2.FindSet();        TempDimensionPostingBuffer.DeleteAll();        repeat            IsHandled := false;            OnOnUnapplyCustLedgEntryOnBeforeProcessDetailedCustLedgEntry2InLoop(DetailedCustLedgEntry2, IsHandled);            if not IsHandled then begin                CheckDetailedCustLedgEntryUnapply(DetailedCustLedgEntry2);                InsertDtldCustLedgEntryUnapply(                    GenJournalLineToPost, NewDetailedCustLedgEntry, DetailedCustLedgEntry2, NextDtldLedgEntryNo, CustomerPostingGroup);                DetailedCVLedgEntryBuffer.Init();                DetailedCVLedgEntryBuffer.TransferFields(NewDetailedCustLedgEntry);                OnUnapplyCustLedgEntryOnAfterFillDtldCVLedgEntryBuf(GenJournalLineToPost, DetailedCVLedgEntryBuffer);                if CustomerPostingGroup.Code <> DetailedCustLedgEntry2."Posting Group" then                    CustomerPostingGroup.Get(DetailedCustLedgEntry2."Posting Group");                SetAddCurrForUnapplication(DetailedCVLedgEntryBuffer);                CurrencyLCY.InitRoundingPrecision();                if (DetailedCustLedgEntry2."Transaction No." <> 0) and IsVATExcluded(DetailedCustLedgEntry2."Entry Type") then begin                    UnapplyExcludedVAT(                      TempVATEntry2, DetailedCustLedgEntry2."Transaction No.", DetailedCustLedgEntry2."VAT Bus. Posting Group",                      DetailedCustLedgEntry2."VAT Prod. Posting Group", DetailedCustLedgEntry2."Gen. Prod. Posting Group");                    DetailedCVLedgEntryBuffer."VAT Amount (LCY)" :=                      CalcVATAmountFromVATEntry(DetailedCVLedgEntryBuffer."Amount (LCY)", TempVATEntry2, CurrencyLCY);                end;                IsHandled := false;                OnOnUnapplyCustLedgEntryOnBeforeUpdateTotalAmounts(IsHandled, GenJournalLineToPost, DetailedCVLedgEntryBuffer);                if not IsHandled then begin                    UpdateTotalAmounts(TempDimensionPostingBuffer, GenJournalLineToPost."Dimension Set ID", DetailedCVLedgEntryBuffer);                    OnUnapplyCustLedgEntryOnAfterUpdateTotals(GenJournalLineToPost, DetailedCVLedgEntryBuffer);                    if not (DetailedCVLedgEntryBuffer."Entry Type" in [                                                                DetailedCVLedgEntryBuffer."Entry Type"::"Initial Entry",                                                                DetailedCVLedgEntryBuffer."Entry Type"::Application])                    then                        CollectAdjustment(AdjAmount,                          -DetailedCVLedgEntryBuffer."Amount (LCY)", -DetailedCVLedgEntryBuffer."Additional-Currency Amount");                end;                PostDtldCustLedgEntryUnapply(                  GenJournalLineToPost, DetailedCVLedgEntryBuffer, CustomerPostingGroup, DetailedCustLedgEntry2."Transaction No.");                OnUnapplyCustLedgEntryOnBeforeUpdateDetailedCustLedgEntry(DetailedCustLedgEntry2, DetailedCVLedgEntryBuffer);                DetailedCustLedgEntry2.Unapplied := true;                DetailedCustLedgEntry2."Unapplied by Entry No." := NewDetailedCustLedgEntry."Entry No.";                DetailedCustLedgEntry2.Modify();                OnUnapplyCustLedgEntryOnBeforeUpdateCustLedgEntry(DetailedCustLedgEntry2, DetailedCVLedgEntryBuffer);                UpdateCustLedgEntry(DetailedCustLedgEntry2);                OnUnapplyCustLedgEntryOnAfterUpdateCustLedgEntry(GenJournalLine, DetailedCustLedgEntry2, NewDetailedCustLedgEntry, CustomerPostingGroup, GlobalGLEntry);            end;        until DetailedCustLedgEntry2.Next() = 0;        IsHandled := false;        OnBeforeCreateGLEntriesForTotalAmountsUnapplyV19(DetailedCustLedgEntry, CustomerPostingGroup, GenJournalLineToPost, TempDimensionPostingBuffer, IsHandled);        if not IsHandled then            CreateGLEntriesForTotalAmountsUnapply(                GenJournalLineToPost, TempDimensionPostingBuffer, GetCustomerReceivablesAccount(GenJournalLineToPost, CustomerPostingGroup));        OnUnapplyCustLedgEntryOnAfterCreateGLEntriesForTotalAmounts(GenJournalLine, DetailedCustLedgEntry, GLReg);        if IsTempGLEntryBufEmpty() then            DetailedCustLedgEntry.SetZeroTransNo(NextTransactionNo);        CheckPostUnrealizedVAT(GenJournalLineToPost, true);        OnUnapplyCustLedgEntryOnBeforeFinishPosting(GenJournalLine, GlobalGLEntry, CustomerPostingGroup);        FinishPosting(GenJournalLineToPost);    end;    local procedure CheckDetailedCustLedgEntryUnapply(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    var        CustLedgerEntry: Record "Cust. Ledger Entry";    begin        DetailedCustLedgEntry.TestField(Unapplied, false);        if DetailedCustLedgEntry."Posting Group" = '' then begin            CustLedgerEntry.ReadIsolation := IsolationLevel::ReadCommitted;            CustLedgerEntry.Get(DetailedCustLedgEntry."Cust. Ledger Entry No.");            DetailedCustLedgEntry."Posting Group" := CustLedgerEntry."Customer Posting Group";            DetailedCustLedgEntry.Modify();        end;    end;    /// <summary>    /// Creates and posts un-applying entry for currently applied detailed vendor ledger entry.    /// G/l entry with unapplied amount is created as part of the process    /// Related vendor ledger entry is being updated as part of the process    /// Unrealized vat is posted    /// </summary>    /// <remarks>    /// Vendor, detailed vendor ledger and vat entries are being locked    /// </remarks>    /// <param name="GenJournalLine">Gen. journal line being posted.</param>    /// <param name="DetailedVendorLedgEntry">Detailed ledger entry that is currently applied</param>    procedure UnapplyVendLedgEntry(GenJournalLine: Record "Gen. Journal Line"; DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry")    var        Vendor: Record Vendor;        VendorPostingGroup: Record "Vendor Posting Group";        GenJournalLineToPost: Record "Gen. Journal Line";        DetailedVendorLedgEntry2: Record "Detailed Vendor Ledg. Entry";        NewDetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry";        VendorLedgerEntry: Record "Vendor Ledger Entry";        DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer";        VATEntry: Record "VAT Entry";        TempVATEntry2: Record "VAT Entry" temporary;        CurrencyLCY: Record Currency;        TempDimensionPostingBuffer: Record "Dimension Posting Buffer" temporary;        AdjAmount: array[4] of Decimal;        NextDtldLedgEntryNo: Integer;        UnapplyVATEntries: Boolean;        PmtDiscTolExists: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUnapplyVendLedgEntry(GenJournalLine, DetailedVendorLedgEntry, IsHandled);        if IsHandled then            exit;        GenJournalLineToPost.TransferFields(GenJournalLine);        if GenJournalLineToPost."Document Date" = 0D then            GenJournalLineToPost."Document Date" := GenJournalLineToPost."Posting Date";        AmountRoundingPrecision := GetSourceCurrency(GenJournalLine."Source Currency Code");        if NextEntryNo = 0 then            StartPosting(GenJournalLineToPost)        else            ContinuePosting(GenJournalLineToPost);        ReadGLSetup(GLSetup);        Vendor.Get(DetailedVendorLedgEntry."Vendor No.");        Vendor.CheckBlockedVendOnJnls(Vendor, GenJournalLine."Document Type"::Payment, true);        OnUnapplyVendLedgEntryOnBeforeCheckPostingGroup(GenJournalLineToPost, Vendor);        GetVendorPostingGroup(GenJournalLineToPost, VendorPostingGroup);        VendorPostingGroup.GetPayablesAccount();        VATEntry.LockTable();        DetailedVendorLedgEntry.LockTable();        VendorLedgerEntry.LockTable();        DetailedVendorLedgEntry.TestField("Entry Type", DetailedVendorLedgEntry."Entry Type"::Application);        DetailedVendorLedgEntry2.Reset();        DetailedVendorLedgEntry2.FindLast();        NextDtldLedgEntryNo := DetailedVendorLedgEntry2."Entry No." + 1;        if DetailedVendorLedgEntry."Transaction No." = 0 then begin            DetailedVendorLedgEntry2.SetCurrentKey("Application No.", "Vendor No.", "Entry Type");            DetailedVendorLedgEntry2.SetRange("Application No.", DetailedVendorLedgEntry."Application No.");        end else begin            DetailedVendorLedgEntry2.SetCurrentKey("Transaction No.", "Vendor No.", "Entry Type");            DetailedVendorLedgEntry2.SetRange("Transaction No.", DetailedVendorLedgEntry."Transaction No.");        end;        DetailedVendorLedgEntry2.SetRange("Vendor No.", DetailedVendorLedgEntry."Vendor No.");        MultiplePostingGroups := CheckDetVendLedgEntryMultiplePostingGrOnBeforeUnapply(DetailedVendorLedgEntry2, DetailedVendorLedgEntry);        DetailedVendorLedgEntry2.SetFilter("Entry Type", '>%1', DetailedVendorLedgEntry."Entry Type"::"Initial Entry");        OnUnapplyVendLedgEntryOnAfterFilterSourceEntries(DetailedVendorLedgEntry, DetailedVendorLedgEntry2);        if DetailedVendorLedgEntry."Transaction No." <> 0 then begin            UnapplyVATEntries := false;            DetailedVendorLedgEntry2.FindSet();            repeat                DetailedVendorLedgEntry2.TestField(Unapplied, false);                if IsVATAdjustment(DetailedVendorLedgEntry2."Entry Type") then                    UnapplyVATEntries := true;                if not GLSetup."Pmt. Disc. Excl. VAT" and GLSetup."Adjust for Payment Disc." then                    if IsVATExcluded(DetailedVendorLedgEntry2."Entry Type") then                        UnapplyVATEntries := true;                if DetailedVendorLedgEntry2."Entry Type" = DetailedVendorLedgEntry2."Entry Type"::"Payment Discount Tolerance (VAT Excl.)" then                    PmtDiscTolExists := true;            until DetailedVendorLedgEntry2.Next() = 0;            OnUnapplyVendLedgEntryOnBeforePostUnapply(DetailedVendorLedgEntry, DetailedVendorLedgEntry2);            PostUnapply(              GenJournalLineToPost, VATEntry, VATEntry.Type::Purchase,              DetailedVendorLedgEntry."Vendor No.", DetailedVendorLedgEntry."Transaction No.", UnapplyVATEntries, TempVATEntry);            OnUnapplyVendLedgEntryOnAfterPostUnapply(GenJournalLineToPost, DetailedVendorLedgEntry, DetailedVendorLedgEntry2);            if PmtDiscTolExists then                ProcessTempVATEntryVend(DetailedVendorLedgEntry2, TempVATEntry)            else begin                DetailedVendorLedgEntry2.SetRange("Entry Type", DetailedVendorLedgEntry2."Entry Type"::"Payment Tolerance (VAT Excl.)");                ProcessTempVATEntryVend(DetailedVendorLedgEntry2, TempVATEntry);                DetailedVendorLedgEntry2.SetRange("Entry Type", DetailedVendorLedgEntry2."Entry Type"::"Payment Discount (VAT Excl.)");                ProcessTempVATEntryVend(DetailedVendorLedgEntry2, TempVATEntry);                DetailedVendorLedgEntry2.SetFilter("Entry Type", '>%1', DetailedVendorLedgEntry2."Entry Type"::"Initial Entry");            end;        end;        // Look one more time        OnUnapplyVendLedgEntryOnBeforeSecondLook(DetailedVendorLedgEntry2, NextDtldLedgEntryNo);        DetailedVendorLedgEntry2.FindSet();        TempDimensionPostingBuffer.DeleteAll();        repeat            CheckDetailedVendLedgEntryUnapply(DetailedVendorLedgEntry2);            InsertDtldVendLedgEntryUnapply(GenJournalLineToPost, NewDetailedVendorLedgEntry, DetailedVendorLedgEntry2, NextDtldLedgEntryNo);            DetailedCVLedgEntryBuffer.Init();            DetailedCVLedgEntryBuffer.TransferFields(NewDetailedVendorLedgEntry);            OnUnapplyVendLedgEntryOnAfterFillDtldCVLedgEntryBuf(GenJournalLineToPost, DetailedCVLedgEntryBuffer);            if VendorPostingGroup.Code <> DetailedVendorLedgEntry2."Posting Group" then                VendorPostingGroup.Get(DetailedVendorLedgEntry2."Posting Group");            SetAddCurrForUnapplication(DetailedCVLedgEntryBuffer);            CurrencyLCY.InitRoundingPrecision();            if (DetailedVendorLedgEntry2."Transaction No." <> 0) and IsVATExcluded(DetailedVendorLedgEntry2."Entry Type") then begin                UnapplyExcludedVAT(                  TempVATEntry2, DetailedVendorLedgEntry2."Transaction No.", DetailedVendorLedgEntry2."VAT Bus. Posting Group",                  DetailedVendorLedgEntry2."VAT Prod. Posting Group", DetailedVendorLedgEntry2."Gen. Prod. Posting Group");                DetailedCVLedgEntryBuffer."VAT Amount (LCY)" :=                  CalcVATAmountFromVATEntry(DetailedCVLedgEntryBuffer."Amount (LCY)", TempVATEntry2, CurrencyLCY);            end;            IsHandled := false;            OnUnapplyVendLedgEntryOnBeforeUpdateTotalAmounts(IsHandled, GenJournalLineToPost, DetailedCVLedgEntryBuffer);            if not IsHandled then begin                UpdateTotalAmounts(TempDimensionPostingBuffer, GenJournalLineToPost."Dimension Set ID", DetailedCVLedgEntryBuffer);                if not (DetailedCVLedgEntryBuffer."Entry Type" in [                                                            DetailedCVLedgEntryBuffer."Entry Type"::"Initial Entry",                                                            DetailedCVLedgEntryBuffer."Entry Type"::Application])                then                    CollectAdjustment(AdjAmount,                      -DetailedCVLedgEntryBuffer."Amount (LCY)", -DetailedCVLedgEntryBuffer."Additional-Currency Amount");            end;            PostDtldVendLedgEntryUnapply(              GenJournalLineToPost, DetailedCVLedgEntryBuffer, VendorPostingGroup, DetailedVendorLedgEntry2."Transaction No.");            OnUnapplyVendLedgEntryOnBeforeUpdateDetailedVendLedgEntry2(DetailedVendorLedgEntry2, DetailedCVLedgEntryBuffer);            DetailedVendorLedgEntry2.Unapplied := true;            DetailedVendorLedgEntry2."Unapplied by Entry No." := NewDetailedVendorLedgEntry."Entry No.";            DetailedVendorLedgEntry2.Modify();            OnUnapplyVendLedgEntryOnBeforeUpdateVendLedgEntry(DetailedVendorLedgEntry2, DetailedCVLedgEntryBuffer);            UpdateVendLedgEntry(DetailedVendorLedgEntry2);        until DetailedVendorLedgEntry2.Next() = 0;        IsHandled := false;        OnBeforeCreateGLEntriesForTotalAmountsUnapplyVendorV19(DetailedVendorLedgEntry, VendorPostingGroup, GenJournalLineToPost, TempDimensionPostingBuffer, IsHandled);        if not IsHandled then            CreateGLEntriesForTotalAmountsUnapply(GenJournalLineToPost, TempDimensionPostingBuffer, GetVendorPayablesAccount(GenJournalLineToPost, VendorPostingGroup));        OnUnapplyVendLedgEntryOnAfterCreateGLEntriesForTotalAmounts(GenJournalLine, DetailedVendorLedgEntry, GLReg, GenJournalLineToPost, NextTaxEntryNo, NextEntryNo, NextCheckEntryNo, NextTransactionNo);        if IsTempGLEntryBufEmpty() then            DetailedVendorLedgEntry.SetZeroTransNo(NextTransactionNo);        CheckPostUnrealizedVAT(GenJournalLineToPost, true);        FinishPosting(GenJournalLineToPost);        OnAfterUnapplyVendLedgEntry(GenJournalLine, DetailedVendorLedgEntry);    end;    local procedure CheckDetailedVendLedgEntryUnapply(var DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry")    var        VendorLedgerEntry: Record "Vendor Ledger Entry";    begin        DetailedVendorLedgEntry.TestField(Unapplied, false);        if DetailedVendorLedgEntry."Posting Group" = '' then begin            VendorLedgerEntry.ReadIsolation := IsolationLevel::ReadCommitted;            VendorLedgerEntry.Get(DetailedVendorLedgEntry."Vendor Ledger Entry No.");            DetailedVendorLedgEntry."Posting Group" := VendorLedgerEntry."Vendor Posting Group";            DetailedVendorLedgEntry.Modify();        end;    end;    /// <summary>    /// Creates and posts un-applying entry for currently applied detailed employee ledger entry.    /// G/l entry with unapplied amount is created as part of the process    /// Related employee ledger entry is being updated as part of the process    /// </summary>    /// <remarks>    /// Employee and detailed employee ledger entries are being locked    /// </remarks>    /// <param name="GenJournalLine">Gen. journal line being posted.</param>    /// <param name="DetailedEmployeeLedgerEntry">Detailed Employee Ledger Entry that is currently applied</param>    procedure UnapplyEmplLedgEntry(GenJournalLine: Record "Gen. Journal Line"; DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry")    var        Employee: Record Employee;        EmployeePostingGroup: Record "Employee Posting Group";        GenJournalLineToPost: Record "Gen. Journal Line";        DetailedEmployeeLedgerEntry2: Record "Detailed Employee Ledger Entry";        NewDetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry";        EmployeeLedgerEntry: Record "Employee Ledger Entry";        DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer";        CurrencyLCY: Record Currency;        TempDimensionPostingBuffer: Record "Dimension Posting Buffer" temporary;        AdjAmount: array[4] of Decimal;        NextDtldLedgEntryNo: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUnapplyEmplLedgEntry(GenJournalLine, DetailedEmployeeLedgerEntry, IsHandled);        if IsHandled then            exit;        GenJournalLineToPost.TransferFields(GenJournalLine);        if GenJournalLineToPost."Document Date" = 0D then            GenJournalLineToPost."Document Date" := GenJournalLineToPost."Posting Date";        AmountRoundingPrecision := GetSourceCurrency(GenJournalLine."Source Currency Code");        if NextEntryNo = 0 then            StartPosting(GenJournalLineToPost)        else            ContinuePosting(GenJournalLineToPost);        ReadGLSetup(GLSetup);        Employee.Get(DetailedEmployeeLedgerEntry."Employee No.");        Employee.CheckBlockedEmployeeOnJnls(true);        EmployeePostingGroup.Get(GenJournalLineToPost."Posting Group");        EmployeePostingGroup.GetPayablesAccount();        DetailedEmployeeLedgerEntry.LockTable();        EmployeeLedgerEntry.LockTable();        DetailedEmployeeLedgerEntry.TestField("Entry Type", DetailedEmployeeLedgerEntry."Entry Type"::Application);        DetailedEmployeeLedgerEntry2.Reset();        DetailedEmployeeLedgerEntry2.FindLast();        NextDtldLedgEntryNo := DetailedEmployeeLedgerEntry2."Entry No." + 1;        if DetailedEmployeeLedgerEntry."Transaction No." = 0 then begin            DetailedEmployeeLedgerEntry2.SetCurrentKey("Application No.", "Employee No.", "Entry Type");            DetailedEmployeeLedgerEntry2.SetRange("Application No.", DetailedEmployeeLedgerEntry."Application No.");        end else begin            DetailedEmployeeLedgerEntry2.SetCurrentKey("Transaction No.", "Employee No.", "Entry Type");            DetailedEmployeeLedgerEntry2.SetRange("Transaction No.", DetailedEmployeeLedgerEntry."Transaction No.");        end;        DetailedEmployeeLedgerEntry2.SetRange("Employee No.", DetailedEmployeeLedgerEntry."Employee No.");        MultiplePostingGroups := CheckDetEmplLedgEntryMultiplePostingGrOnBeforeUnapply(DetailedEmployeeLedgerEntry2, DetailedEmployeeLedgerEntry);        DetailedEmployeeLedgerEntry2.SetFilter("Entry Type", '>%1', DetailedEmployeeLedgerEntry."Entry Type"::"Initial Entry");        OnUnapplyEmplLedgEntryOnAfterFilterSourceEntries(DetailedEmployeeLedgerEntry, DetailedEmployeeLedgerEntry2);        // Look one more time        DetailedEmployeeLedgerEntry2.FindSet();        TempDimensionPostingBuffer.DeleteAll();        repeat            DetailedEmployeeLedgerEntry.TestField(Unapplied, false);            UpdateEmployeePostingGroup(DetailedEmployeeLedgerEntry2);            InsertDtldEmplLedgEntryUnapply(GenJournalLineToPost, NewDetailedEmployeeLedgerEntry, DetailedEmployeeLedgerEntry2, NextDtldLedgEntryNo);            DetailedCVLedgEntryBuffer.Init();            DetailedCVLedgEntryBuffer.TransferFields(NewDetailedEmployeeLedgerEntry);            if EmployeePostingGroup.Code <> DetailedEmployeeLedgerEntry2."Posting Group" then                EmployeePostingGroup.Get(DetailedEmployeeLedgerEntry2."Posting Group");            SetAddCurrForUnapplication(DetailedCVLedgEntryBuffer);            CurrencyLCY.InitRoundingPrecision();            IsHandled := false;            OnUnapplyEmplLedgEntryOnBeforeUpdateTotalAmounts(GenJournalLineToPost, DetailedCVLedgEntryBuffer, IsHandled);            if not IsHandled then begin                UpdateTotalAmounts(TempDimensionPostingBuffer, GenJournalLineToPost."Dimension Set ID", DetailedCVLedgEntryBuffer);                if not (DetailedCVLedgEntryBuffer."Entry Type" in [                                                            DetailedCVLedgEntryBuffer."Entry Type"::"Initial Entry",                                                            DetailedCVLedgEntryBuffer."Entry Type"::Application])                then                    CollectAdjustment(AdjAmount,                      -DetailedCVLedgEntryBuffer."Amount (LCY)", -DetailedCVLedgEntryBuffer."Additional-Currency Amount");            end;            PostDtldEmplLedgEntryUnapply(                GenJournalLineToPost, DetailedCVLedgEntryBuffer, EmployeePostingGroup, DetailedEmployeeLedgerEntry2."Transaction No.");            DetailedEmployeeLedgerEntry2.Unapplied := true;            DetailedEmployeeLedgerEntry2."Unapplied by Entry No." := NewDetailedEmployeeLedgerEntry."Entry No.";            DetailedEmployeeLedgerEntry2.Modify();            UpdateEmplLedgEntry(DetailedEmployeeLedgerEntry2);        until DetailedEmployeeLedgerEntry2.Next() = 0;        IsHandled := false;        OnBeforeCreateGLEntriesForTotalAmountsUnapplyEmployee(DetailedEmployeeLedgerEntry, EmployeePostingGroup, GenJournalLineToPost, TempDimensionPostingBuffer, IsHandled);        if not IsHandled then            CreateGLEntriesForTotalAmountsUnapply(GenJournalLineToPost, TempDimensionPostingBuffer, GetEmployeePayablesAccount(GenJournalLineToPost, EmployeePostingGroup));        if IsTempGLEntryBufEmpty() then            DetailedEmployeeLedgerEntry.SetZeroTransNo(NextTransactionNo);        FinishPosting(GenJournalLineToPost);        OnAfterUnapplyEmplLedgEntry(GenJournalLine, DetailedEmployeeLedgerEntry);    end;    local procedure UpdateEmployeePostingGroup(var DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry")    var        EmployeeLedgerEntry: Record "Employee Ledger Entry";    begin        if DetailedEmployeeLedgerEntry."Posting Group" = '' then begin            EmployeeLedgerEntry.ReadIsolation := IsolationLevel::ReadCommitted;            EmployeeLedgerEntry.Get(DetailedEmployeeLedgerEntry."Employee Ledger Entry No.");            DetailedEmployeeLedgerEntry."Posting Group" := EmployeeLedgerEntry."Employee Posting Group";            DetailedEmployeeLedgerEntry.Modify();        end;    end;    local procedure UnapplyExcludedVAT(var TempVATEntry: Record "VAT Entry" temporary; TransactionNo: Integer; VATBusPostingGroup: Code[20]; VATProdPostingGroup: Code[20]; GenProdPostingGroup: Code[20])    begin        TempVATEntry.SetRange("VAT Bus. Posting Group", VATBusPostingGroup);        TempVATEntry.SetRange("VAT Prod. Posting Group", VATProdPostingGroup);        TempVATEntry.SetRange("Gen. Prod. Posting Group", GenProdPostingGroup);        if not TempVATEntry.FindFirst() then begin            TempVATEntry.Reset();            if TempVATEntry.FindLast() then                TempVATEntry."Entry No." := TempVATEntry."Entry No." + 1            else                TempVATEntry."Entry No." := 1;            TempVATEntry.Init();            TempVATEntry."VAT Bus. Posting Group" := VATBusPostingGroup;            TempVATEntry."VAT Prod. Posting Group" := VATProdPostingGroup;            TempVATEntry."Gen. Prod. Posting Group" := GenProdPostingGroup;            VATEntry.SetCurrentKey("Transaction No.");            VATEntry.SetRange("Transaction No.", TransactionNo);            VATEntry.SetRange("VAT Bus. Posting Group", VATBusPostingGroup);            VATEntry.SetRange("VAT Prod. Posting Group", VATProdPostingGroup);            VATEntry.SetRange("Gen. Prod. Posting Group", GenProdPostingGroup);            if VATEntry.FindSet() then                repeat                    if VATEntry."Unrealized VAT Entry No." = 0 then begin                        TempVATEntry.Base := TempVATEntry.Base + VATEntry.Base;                        TempVATEntry.Amount := TempVATEntry.Amount + VATEntry.Amount;                    end;                until VATEntry.Next() = 0;            Clear(VATEntry);            TempVATEntry.Insert();        end;    end;    local procedure PostUnrealVATByUnapply(GenJnlLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; VATEntry: Record "VAT Entry"; NewVATEntry: Record "VAT Entry"): Integer    var        VATEntry2: Record "VAT Entry";        AmountAddCurr: Decimal;        GLEntryNoFromVAT: Integer;    begin        OnBeforePostUnrealVATByUnapply(GenJnlLine, VATPostingSetup, VATEntry, NewVATEntry);        AmountAddCurr := CalcAddCurrForUnapplication(VATEntry."Posting Date", VATEntry.Amount);        CreateGLEntry(            GenJnlLine, GetPostingAccountNo(VATPostingSetup, VATEntry, true), VATEntry.Amount, AmountAddCurr, false,            CalcAmountSrcCurr(GenJnlLine, VATEntry.Amount));        GLEntryNoFromVAT :=          CreateGLEntryFromVATEntry(            GenJnlLine, GetPostingAccountNo(VATPostingSetup, VATEntry, false), -VATEntry.Amount, -AmountAddCurr, VATEntry);        VATEntry2.Get(VATEntry."Unrealized VAT Entry No.");        VATEntry2."Remaining Unrealized Amount" := VATEntry2."Remaining Unrealized Amount" - NewVATEntry.Amount;        VATEntry2."Remaining Unrealized Base" := VATEntry2."Remaining Unrealized Base" - NewVATEntry.Base;        VATEntry2."Add.-Curr. Rem. Unreal. Amount" :=          VATEntry2."Add.-Curr. Rem. Unreal. Amount" - NewVATEntry."Additional-Currency Amount";        VATEntry2."Add.-Curr. Rem. Unreal. Base" :=          VATEntry2."Add.-Curr. Rem. Unreal. Base" - NewVATEntry."Additional-Currency Base";        OnPostUnrealVATByUnapplyOnBeforeVATEntryModify(GenJnlLine, VATPostingSetup, VATEntry, NewVATEntry, VATEntry2, GLEntryNoFromVAT);        VATEntry2.Modify();        OnAfterPostUnrealVATByUnapply(GenJnlLine, VATPostingSetup, VATEntry, NewVATEntry);        exit(GLEntryNoFromVAT);    end;    local procedure PostPmtDiscountVATByUnapply(GenJnlLine: Record "Gen. Journal Line"; ReverseChargeVATAccNo: Code[20]; VATAccNo: Code[20]; VATEntry: Record "VAT Entry")    var        AmountAddCurr: Decimal;    begin        OnBeforePostPmtDiscountVATByUnapply(GenJnlLine, VATEntry);        AmountAddCurr := CalcAddCurrForUnapplication(VATEntry."Posting Date", VATEntry.Amount);        CreateGLEntry(            GenJnlLine, ReverseChargeVATAccNo, VATEntry.Amount, AmountAddCurr, false,            CalcAmountSrcCurr(GenJnlLine, VATEntry.Amount));        CreateGLEntry(            GenJnlLine, VATAccNo, -VATEntry.Amount, -AmountAddCurr, false,            CalcAmountSrcCurr(GenJnlLine, -VATEntry.Amount));        OnAfterPostPmtDiscountVATByUnapply(GenJnlLine, VATEntry);    end;    local procedure PostUnapply(GenJnlLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry"; VATEntryType: Enum "General Posting Type"; BilltoPaytoNo: Code[20]; TransactionNo: Integer; UnapplyVATEntries: Boolean; var TempVATEntry: Record "VAT Entry" temporary)    var        VATPostingSetup: Record "VAT Posting Setup";        VATEntry2: Record "VAT Entry";        AccNo: Code[20];        TempVATEntryNo: Integer;        GLEntryNoFromVAT: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforePostUnapply(GenJnlLine, VATEntry, VATEntryType, BilltoPaytoNo, TransactionNo, UnapplyVATEntries, TempVATEntry, IsHandled, NextVATEntryNo);        if IsHandled then            exit;        TempVATEntryNo := 1;        VATEntry.SetCurrentKey(Type, "Bill-to/Pay-to No.", "Transaction No.");        VATEntry.SetRange(Type, VATEntryType);        VATEntry.SetRange("Bill-to/Pay-to No.", BilltoPaytoNo);        VATEntry.SetRange("Transaction No.", TransactionNo);        OnPostUnapplyOnAfterVATEntrySetFilters(VATEntry, GenJnlLine);        if VATEntry.FindSet() then            repeat                VATPostingSetup.Get(VATEntry."VAT Bus. Posting Group", VATEntry."VAT Prod. Posting Group");                OnPostUnapplyOnBeforeUnapplyVATEntry(VATEntry, UnapplyVATEntries);                if UnapplyVATEntries or (VATEntry."Unrealized VAT Entry No." <> 0) then begin                    OnPostUnapplyOnBeforeInsertTempVATEntry(VATEntry, UnapplyVATEntries);                    InsertTempVATEntry(GenJnlLine, VATEntry, TempVATEntryNo, TempVATEntry);                    if VATEntry."Unrealized VAT Entry No." <> 0 then begin                        VATPostingSetup.Get(VATEntry."VAT Bus. Posting Group", VATEntry."VAT Prod. Posting Group");                        if VATPostingSetup."VAT Calculation Type" in                           [VATPostingSetup."VAT Calculation Type"::"Normal VAT",                            VATPostingSetup."VAT Calculation Type"::"Full VAT"]                        then                            GLEntryNoFromVAT := PostUnrealVATByUnapply(GenJnlLine, VATPostingSetup, VATEntry, TempVATEntry)                        else                            if VATPostingSetup."VAT Calculation Type" = VATPostingSetup."VAT Calculation Type"::"Reverse Charge VAT" then begin                                GLEntryNoFromVAT := PostUnrealVATByUnapply(GenJnlLine, VATPostingSetup, VATEntry, TempVATEntry);                                CreateGLEntry(                                    GenJnlLine, VATPostingSetup.GetRevChargeAccount(true),                                    -VATEntry.Amount, CalcAddCurrForUnapplication(VATEntry."Posting Date", -VATEntry.Amount), false,                                    CalcAmountSrcCurr(GenJnlLine, -VATEntry.Amount));                                CreateGLEntry(                                    GenJnlLine, VATPostingSetup.GetRevChargeAccount(false),                                    VATEntry.Amount, CalcAddCurrForUnapplication(VATEntry."Posting Date", VATEntry.Amount), false,                                    CalcAmountSrcCurr(GenJnlLine, VATEntry.Amount));                            end else                                GLEntryNoFromVAT := PostUnrealVATByUnapply(GenJnlLine, VATPostingSetup, VATEntry, TempVATEntry);                        VATEntry2 := TempVATEntry;                        VATEntry2."Entry No." := NextVATEntryNo;                        VATEntry2."G/L Register No." := GLReg."No.";                        OnPostUnapplyOnBeforeVATEntryInsert(VATEntry2, GenJnlLine, VATEntry);                        VATEntry2.Insert();                        OnPostUnapplyOnAfterVATEntryInsert(VATEntry2, GenJnlLine, VATEntry);                        if GLEntryNoFromVAT <> 0 then                            TempGLEntryVATEntryLink.InsertLinkSelf(GLEntryNoFromVAT, VATEntry2."Entry No.");                        GLEntryNoFromVAT := 0;                        TempVATEntry.Delete();                        IncrNextVATEntryNo();                    end;                    if VATPostingSetup."Adjust for Payment Discount" and not IsNotPayment(VATEntry."Document Type") and                       (VATPostingSetup."VAT Calculation Type" =                        VATPostingSetup."VAT Calculation Type"::"Reverse Charge VAT") and                       (VATEntry."Unrealized VAT Entry No." = 0) and UnapplyVATEntries and (VATEntry.Amount <> 0)                    then begin                        case VATEntryType of                            VATEntry.Type::Sale:                                AccNo := VATPostingSetup.GetSalesAccount(false);                            VATEntry.Type::Purchase:                                AccNo := VATPostingSetup.GetPurchAccount(false);                        end;                        PostPmtDiscountVATByUnapply(GenJnlLine, VATPostingSetup.GetRevChargeAccount(false), AccNo, VATEntry);                    end;                end;            until VATEntry.Next() = 0;    end;    local procedure CalcAddCurrForUnapplication(Date: Date; Amt: Decimal): Decimal    var        AddCurrency: Record Currency;        CurrExchRate: Record "Currency Exchange Rate";    begin        if AddCurrencyCode = '' then            exit;        AddCurrency.Get(AddCurrencyCode);        AddCurrency.TestField("Amount Rounding Precision");        exit(          Round(            CurrExchRate.ExchangeAmtLCYToFCY(              Date, AddCurrencyCode, Amt, CurrExchRate.ExchangeRate(Date, AddCurrencyCode)),            AddCurrency."Amount Rounding Precision"));    end;    local procedure CalcVATAmountFromVATEntry(AmountLCY: Decimal; var VATEntry: Record "VAT Entry"; CurrencyLCY: Record Currency) VATAmountLCY: Decimal    begin        if (AmountLCY = VATEntry.Base) or (VATEntry.Base = 0) then begin            VATAmountLCY := VATEntry.Amount;            VATEntry.Delete();        end else begin            VATAmountLCY :=              Round(                VATEntry.Amount * AmountLCY / VATEntry.Base,                CurrencyLCY."Amount Rounding Precision",                CurrencyLCY.VATRoundingDirection());            VATEntry.Base := VATEntry.Base - AmountLCY;            VATEntry.Amount := VATEntry.Amount - VATAmountLCY;            VATEntry.Modify();        end;    end;    local procedure InsertDtldCustLedgEntryUnapply(GenJnlLine: Record "Gen. Journal Line"; var NewDtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var OldDtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var NextDtldLedgEntryNo: Integer; var CustomerPostingGroup: Record "Customer Posting Group")    begin        NewDtldCustLedgEntry := OldDtldCustLedgEntry;        NewDtldCustLedgEntry."Entry No." := NextDtldLedgEntryNo;        NewDtldCustLedgEntry."Posting Date" := GenJnlLine."Posting Date";        NewDtldCustLedgEntry."Transaction No." := NextTransactionNo;        NewDtldCustLedgEntry."Application No." := 0;        NewDtldCustLedgEntry.Amount := -OldDtldCustLedgEntry.Amount;        NewDtldCustLedgEntry."Amount (LCY)" := -OldDtldCustLedgEntry."Amount (LCY)";        NewDtldCustLedgEntry."Debit Amount" := -OldDtldCustLedgEntry."Debit Amount";        NewDtldCustLedgEntry."Credit Amount" := -OldDtldCustLedgEntry."Credit Amount";        NewDtldCustLedgEntry."Debit Amount (LCY)" := -OldDtldCustLedgEntry."Debit Amount (LCY)";        NewDtldCustLedgEntry."Credit Amount (LCY)" := -OldDtldCustLedgEntry."Credit Amount (LCY)";        NewDtldCustLedgEntry.Unapplied := true;        NewDtldCustLedgEntry."Unapplied by Entry No." := OldDtldCustLedgEntry."Entry No.";        NewDtldCustLedgEntry."Document No." := GenJnlLine."Document No.";        NewDtldCustLedgEntry."Source Code" := GenJnlLine."Source Code";        NewDtldCustLedgEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewDtldCustLedgEntry."User ID"));        NewDtldCustLedgEntry."Posting Group" := OldDtldCustLedgEntry."Posting Group";        NewDtldCustLedgEntry."G/L Register No." := GLReg."No.";        OnBeforeInsertDtldCustLedgEntryUnapply(NewDtldCustLedgEntry, GenJnlLine, OldDtldCustLedgEntry, GLReg);        NewDtldCustLedgEntry.Insert(true);        NextDtldLedgEntryNo := NextDtldLedgEntryNo + 1;        OnAfterInsertDtldCustLedgEntryUnapply(CustomerPostingGroup, OldDtldCustLedgEntry, GenJnlLine, NewDtldCustLedgEntry);    end;    local procedure InsertDtldVendLedgEntryUnapply(GenJnlLine: Record "Gen. Journal Line"; var NewDtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; OldDtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; var NextDtldLedgEntryNo: Integer)    begin        NewDtldVendLedgEntry := OldDtldVendLedgEntry;        NewDtldVendLedgEntry."Entry No." := NextDtldLedgEntryNo;        NewDtldVendLedgEntry."Posting Date" := GenJnlLine."Posting Date";        NewDtldVendLedgEntry."Transaction No." := NextTransactionNo;        NewDtldVendLedgEntry."Application No." := 0;        NewDtldVendLedgEntry.Amount := -OldDtldVendLedgEntry.Amount;        NewDtldVendLedgEntry."Amount (LCY)" := -OldDtldVendLedgEntry."Amount (LCY)";        NewDtldVendLedgEntry."Debit Amount" := -OldDtldVendLedgEntry."Debit Amount";        NewDtldVendLedgEntry."Credit Amount" := -OldDtldVendLedgEntry."Credit Amount";        NewDtldVendLedgEntry."Debit Amount (LCY)" := -OldDtldVendLedgEntry."Debit Amount (LCY)";        NewDtldVendLedgEntry."Credit Amount (LCY)" := -OldDtldVendLedgEntry."Credit Amount (LCY)";        NewDtldVendLedgEntry.Unapplied := true;        NewDtldVendLedgEntry."Unapplied by Entry No." := OldDtldVendLedgEntry."Entry No.";        NewDtldVendLedgEntry."Document No." := GenJnlLine."Document No.";        NewDtldVendLedgEntry."Source Code" := GenJnlLine."Source Code";        NewDtldVendLedgEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewDtldVendLedgEntry."User ID"));        NewDtldVendLedgEntry."Posting Group" := OldDtldVendLedgEntry."Posting Group";        NewDtldVendLedgEntry."G/L Register No." := GLReg."No.";        OnBeforeInsertDtldVendLedgEntryUnapply(NewDtldVendLedgEntry, GenJnlLine, OldDtldVendLedgEntry, GLReg);        NewDtldVendLedgEntry.Insert(true);        NextDtldLedgEntryNo := NextDtldLedgEntryNo + 1;        OnAfterInsertDtldVendLedgEntryUnapply(OldDtldVendLedgEntry, GenJnlLine, NewDtldVendLedgEntry);    end;    local procedure InsertDtldEmplLedgEntryUnapply(GenJnlLine: Record "Gen. Journal Line"; var NewDtldEmplLedgEntry: Record "Detailed Employee Ledger Entry"; OldDtldEmplLedgEntry: Record "Detailed Employee Ledger Entry"; var NextDtldLedgEntryNo: Integer)    begin        NewDtldEmplLedgEntry := OldDtldEmplLedgEntry;        NewDtldEmplLedgEntry."Entry No." := NextDtldLedgEntryNo;        NewDtldEmplLedgEntry."Posting Date" := GenJnlLine."Posting Date";        NewDtldEmplLedgEntry."Transaction No." := NextTransactionNo;        NewDtldEmplLedgEntry."Application No." := 0;        NewDtldEmplLedgEntry.Amount := -OldDtldEmplLedgEntry.Amount;        NewDtldEmplLedgEntry."Amount (LCY)" := -OldDtldEmplLedgEntry."Amount (LCY)";        NewDtldEmplLedgEntry."Debit Amount" := -OldDtldEmplLedgEntry."Debit Amount";        NewDtldEmplLedgEntry."Credit Amount" := -OldDtldEmplLedgEntry."Credit Amount";        NewDtldEmplLedgEntry."Debit Amount (LCY)" := -OldDtldEmplLedgEntry."Debit Amount (LCY)";        NewDtldEmplLedgEntry."Credit Amount (LCY)" := -OldDtldEmplLedgEntry."Credit Amount (LCY)";        NewDtldEmplLedgEntry.Unapplied := true;        NewDtldEmplLedgEntry."Unapplied by Entry No." := OldDtldEmplLedgEntry."Entry No.";        NewDtldEmplLedgEntry."Document No." := GenJnlLine."Document No.";        NewDtldEmplLedgEntry."Source Code" := GenJnlLine."Source Code";        NewDtldEmplLedgEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(NewDtldEmplLedgEntry."User ID"));        NewDtldEmplLedgEntry."Posting Group" := OldDtldEmplLedgEntry."Posting Group";        NewDtldEmplLedgEntry."G/L Register No." := GLReg."No.";        OnBeforeInsertDtldEmplLedgEntryUnapply(NewDtldEmplLedgEntry, GenJnlLine, OldDtldEmplLedgEntry);        NewDtldEmplLedgEntry.Insert(true);        NextDtldLedgEntryNo := NextDtldLedgEntryNo + 1;    end;    local procedure InsertTempVATEntry(GenJnlLine: Record "Gen. Journal Line"; VATEntry: Record "VAT Entry"; var TempVATEntryNo: Integer; var TempVATEntry: Record "VAT Entry" temporary)    begin        TempVATEntry := VATEntry;        TempVATEntry."Entry No." := TempVATEntryNo;        TempVATEntryNo := TempVATEntryNo + 1;        TempVATEntry."Closed by Entry No." := 0;        TempVATEntry.Closed := false;        TempVATEntry.CopyAmountsFromVATEntry(VATEntry, true);        TempVATEntry."Posting Date" := GenJnlLine."Posting Date";        TempVATEntry."Document Date" := GenJnlLine."Document Date";        TempVATEntry."VAT Reporting Date" := GenJnlLine."VAT Reporting Date";        TempVATEntry."Document No." := GenJnlLine."Document No.";        TempVATEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(TempVATEntry."User ID"));        TempVATEntry."Transaction No." := NextTransactionNo;        TempVATEntry."G/L Acc. No." := '';        TempVATEntry."G/L Register No." := GLReg."No.";        OnInsertTempVATEntryOnBeforeInsert(TempVATEntry, GenJnlLine, VATEntry);        TempVATEntry.Insert();    end;    local procedure SetGLAccountNoInVATEntries();    var        GLEntryVATEntryLink: Record "G/L Entry - VAT Entry Link";    begin        if TempGLEntryVATEntryLink.FindSet() then            repeat                GLEntryVATEntryLink.InsertLinkSelf(TempGLEntryVATEntryLink."G/L Entry No.", TempGLEntryVATEntryLink."VAT Entry No.");            until TempGLEntryVATEntryLink.Next() = 0;        TempGLEntryVATEntryLink.DeleteAll();    end;    local procedure ProcessTempVATEntry(DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var TempVATEntry: Record "VAT Entry" temporary)    var        VATEntrySaved: Record "VAT Entry";        VATBaseSum: array[3] of Decimal;        DeductedVATBase: Decimal;        EntryNoBegin: array[3] of Integer;        i: Integer;        SummarizedVAT: Boolean;    begin        if not (DtldCVLedgEntryBuf."Entry Type" in                [DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Excl.)",                 DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Excl.)",                 DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Excl.)"])        then            exit;        DeductedVATBase := 0;        TempVATEntry.Reset();        TempVATEntry.SetRange("Entry No.", 0, 999999);        TempVATEntry.SetRange("Gen. Bus. Posting Group", DtldCVLedgEntryBuf."Gen. Bus. Posting Group");        TempVATEntry.SetRange("Gen. Prod. Posting Group", DtldCVLedgEntryBuf."Gen. Prod. Posting Group");        TempVATEntry.SetRange("VAT Bus. Posting Group", DtldCVLedgEntryBuf."VAT Bus. Posting Group");        TempVATEntry.SetRange("VAT Prod. Posting Group", DtldCVLedgEntryBuf."VAT Prod. Posting Group");        if TempVATEntry.FindSet() then            repeat                case true of                    SummarizedVAT and (VATBaseSum[3] + TempVATEntry.Base = DtldCVLedgEntryBuf."Amount (LCY)" - DeductedVATBase):                        i := 4;                    SummarizedVAT and (VATBaseSum[2] + TempVATEntry.Base = DtldCVLedgEntryBuf."Amount (LCY)" - DeductedVATBase):                        i := 3;                    SummarizedVAT and (VATBaseSum[1] + TempVATEntry.Base = DtldCVLedgEntryBuf."Amount (LCY)" - DeductedVATBase):                        i := 2;                    TempVATEntry.Base = DtldCVLedgEntryBuf."Amount (LCY)" - DeductedVATBase:                        i := 1;                    else                        i := 0;                end;                if i > 0 then begin                    TempVATEntry.Reset();                    if i > 1 then begin                        if EntryNoBegin[i - 1] < TempVATEntry."Entry No." then                            TempVATEntry.SetRange("Entry No.", EntryNoBegin[i - 1], TempVATEntry."Entry No.")                        else                            TempVATEntry.SetRange("Entry No.", TempVATEntry."Entry No.", EntryNoBegin[i - 1]);                    end else                        TempVATEntry.SetRange("Entry No.", TempVATEntry."Entry No.");                    TempVATEntry.FindSet();                    repeat                        VATEntrySaved := TempVATEntry;                        case DtldCVLedgEntryBuf."Entry Type" of                            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Excl.)":                                TempVATEntry.Rename(TempVATEntry."Entry No." + 3000000);                            DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Excl.)":                                TempVATEntry.Rename(TempVATEntry."Entry No." + 2000000);                            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Excl.)":                                TempVATEntry.Rename(TempVATEntry."Entry No." + 1000000);                        end;                        TempVATEntry := VATEntrySaved;                        DeductedVATBase += TempVATEntry.Base;                    until TempVATEntry.Next() = 0;                    for i := 1 to 3 do begin                        VATBaseSum[i] := 0;                        EntryNoBegin[i] := 0;                        SummarizedVAT := false;                    end;                    TempVATEntry.SetRange("Entry No.", 0, 999999);                end else begin                    VATBaseSum[3] += TempVATEntry.Base;                    VATBaseSum[2] := VATBaseSum[1] + TempVATEntry.Base;                    VATBaseSum[1] := TempVATEntry.Base;                    if EntryNoBegin[3] > 0 then                        EntryNoBegin[3] := TempVATEntry."Entry No.";                    EntryNoBegin[2] := EntryNoBegin[1];                    EntryNoBegin[1] := TempVATEntry."Entry No.";                    SummarizedVAT := true;                end;            until TempVATEntry.Next() = 0;    end;    local procedure ProcessTempVATEntryCust(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var TempVATEntry: Record "VAT Entry" temporary)    var        DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer";    begin        DetailedCustLedgEntry.SetCurrentKey("Entry No.");        if not DetailedCustLedgEntry.FindSet() then            exit;        repeat            DetailedCVLedgEntryBuffer.Init();            DetailedCVLedgEntryBuffer.TransferFields(DetailedCustLedgEntry);            ProcessTempVATEntry(DetailedCVLedgEntryBuffer, TempVATEntry);            OnProcessTempVATEntryCustOnAfterProcessTempVATEntry(DetailedCVLedgEntryBuffer, TempVATEntry);        until DetailedCustLedgEntry.Next() = 0;    end;    local procedure ProcessTempVATEntryVend(var DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; var TempVATEntry: Record "VAT Entry" temporary)    var        DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer";    begin        if not DetailedVendorLedgEntry.FindSet() then            exit;        repeat            DetailedCVLedgEntryBuffer.Init();            DetailedCVLedgEntryBuffer.TransferFields(DetailedVendorLedgEntry);            ProcessTempVATEntry(DetailedCVLedgEntryBuffer, TempVATEntry);        until DetailedVendorLedgEntry.Next() = 0;    end;    local procedure UpdateCustLedgEntry(DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    var        CustLedgEntry: Record "Cust. Ledger Entry";    begin        if DtldCustLedgEntry."Entry Type" <> DtldCustLedgEntry."Entry Type"::Application then            exit;        CustLedgEntry.Get(DtldCustLedgEntry."Cust. Ledger Entry No.");        CustLedgEntry."Remaining Pmt. Disc. Possible" := DtldCustLedgEntry."Remaining Pmt. Disc. Possible";        CustLedgEntry."Max. Payment Tolerance" := DtldCustLedgEntry."Max. Payment Tolerance";        CustLedgEntry."Accepted Payment Tolerance" := 0;        if not CustLedgEntry.Open then begin            CustLedgEntry.Open := true;            CustLedgEntry."Closed by Entry No." := 0;            CustLedgEntry."Closed at Date" := 0D;            CustLedgEntry."Closed by Amount" := 0;            CustLedgEntry."Closed by Amount (LCY)" := 0;            CustLedgEntry."Closed by Currency Code" := '';            CustLedgEntry."Closed by Currency Amount" := 0;            CustLedgEntry."Pmt. Disc. Given (LCY)" := 0;            CustLedgEntry."Pmt. Tolerance (LCY)" := 0;            CustLedgEntry."Calculate Interest" := false;        end;        OnBeforeCustLedgEntryModify(CustLedgEntry, DtldCustLedgEntry);        CustLedgEntry.Modify();        OnAfterUpdateCustLedgEntry(DtldCustLedgEntry, TempGLEntryBuf, GlobalGLEntry, NextTransactionNo);    end;    local procedure UpdateVendLedgEntry(DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry")    var        VendLedgEntry: Record "Vendor Ledger Entry";    begin        if DtldVendLedgEntry."Entry Type" <> DtldVendLedgEntry."Entry Type"::Application then            exit;        VendLedgEntry.Get(DtldVendLedgEntry."Vendor Ledger Entry No.");        VendLedgEntry."Remaining Pmt. Disc. Possible" := DtldVendLedgEntry."Remaining Pmt. Disc. Possible";        VendLedgEntry."Max. Payment Tolerance" := DtldVendLedgEntry."Max. Payment Tolerance";        VendLedgEntry."Accepted Payment Tolerance" := 0;        if not VendLedgEntry.Open then begin            VendLedgEntry.Open := true;            VendLedgEntry."Closed by Entry No." := 0;            VendLedgEntry."Closed at Date" := 0D;            VendLedgEntry."Closed by Amount" := 0;            VendLedgEntry."Closed by Amount (LCY)" := 0;            VendLedgEntry."Closed by Currency Code" := '';            VendLedgEntry."Closed by Currency Amount" := 0;            VendLedgEntry."Pmt. Disc. Rcd.(LCY)" := 0;            VendLedgEntry."Pmt. Tolerance (LCY)" := 0;            VendLedgEntry."Applies-to Ext. Doc. No." := '';        end;        OnBeforeVendLedgEntryModify(VendLedgEntry, DtldVendLedgEntry);        VendLedgEntry.Modify();        OnAfterUpdateVendLedgEntry(DtldVendLedgEntry, TempGLEntryBuf, GlobalGLEntry, NextTransactionNo);    end;    local procedure UpdateEmplLedgEntry(DtldEmplLedgEntry: Record "Detailed Employee Ledger Entry")    var        EmplLedgEntry: Record "Employee Ledger Entry";    begin        if DtldEmplLedgEntry."Entry Type" <> DtldEmplLedgEntry."Entry Type"::Application then            exit;        EmplLedgEntry.Get(DtldEmplLedgEntry."Employee Ledger Entry No.");        if not EmplLedgEntry.Open then begin            EmplLedgEntry.Open := true;            EmplLedgEntry."Closed by Entry No." := 0;            EmplLedgEntry."Closed at Date" := 0D;            EmplLedgEntry."Closed by Amount" := 0;            EmplLedgEntry."Closed by Amount (LCY)" := 0;            EmplLedgEntry."Closed by Currency Code" := '';            EmplLedgEntry."Closed by Currency Amount" := 0;        end;        OnBeforeEmplLedgEntryModify(EmplLedgEntry, DtldEmplLedgEntry);        EmplLedgEntry.Modify();    end;    local procedure UpdateCalcInterest(var CVLedgEntryBuf: Record "CV Ledger Entry Buffer")    var        CustLedgEntry: Record "Cust. Ledger Entry";        CVLedgEntryBuf2: Record "CV Ledger Entry Buffer";    begin        if CustLedgEntry.Get(CVLedgEntryBuf."Closed by Entry No.") then begin            CVLedgEntryBuf2.TransferFields(CustLedgEntry);            UpdateCalcInterest(CVLedgEntryBuf, CVLedgEntryBuf2);        end;        CustLedgEntry.SetCurrentKey("Closed by Entry No.");        CustLedgEntry.SetRange("Closed by Entry No.", CVLedgEntryBuf."Entry No.");        OnUpdateCalcInterestOnAfterCustLedgEntrySetFilters(CustLedgEntry, CVLedgEntryBuf);        if CustLedgEntry.FindSet() then            repeat                CVLedgEntryBuf2.TransferFields(CustLedgEntry);                UpdateCalcInterest(CVLedgEntryBuf, CVLedgEntryBuf2);            until CustLedgEntry.Next() = 0;    end;    local procedure UpdateCalcInterest(var CVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var CVLedgEntryBuf2: Record "CV Ledger Entry Buffer")    begin        if CVLedgEntryBuf."Due Date" < CVLedgEntryBuf2."Document Date" then            CVLedgEntryBuf."Calculate Interest" := true;    end;    /// <summary>    /// Calculates additional currency amount for G/L posting based on various posting scenarios.    /// Handles currency conversion, rounding, and posting rules for additional currency setup.    /// </summary>    /// <param name="Amount">Base amount in local currency</param>    /// <param name="AddCurrAmount">Amount in additional currency</param>    /// <param name="OldAddCurrAmount">Previous additional currency amount for comparison</param>    /// <param name="UseAddCurrAmount">Indicates whether to use the provided additional currency amount</param>    /// <param name="GenJnlLine">General journal line containing currency posting rules</param>    /// <returns>Calculated additional currency amount for posting</returns>    procedure GLCalcAddCurrency(Amount: Decimal; AddCurrAmount: Decimal; OldAddCurrAmount: Decimal; UseAddCurrAmount: Boolean; GenJnlLine: Record "Gen. Journal Line") Result: Decimal    var        IsHandled: Boolean;    begin        if (AddCurrencyCode <> '') and           (GenJnlLine."Additional-Currency Posting" = GenJnlLine."Additional-Currency Posting"::None)        then begin            if (GenJnlLine."Source Currency Code" = AddCurrencyCode) and UseAddCurrAmount then                exit(AddCurrAmount);            IsHandled := false;            OnGLCalcAddCurrencyPostingNone(GenJnlLine, Amount, AddCurrency, Result, IsHandled);            if IsHandled then                exit(Result);            exit(ExchangeAmtLCYToFCY2(Amount));        end;        exit(OldAddCurrAmount);    end;    local procedure HandleAddCurrResidualGLEntry(GenJnlLine: Record "Gen. Journal Line"; GLEntry2: Record "G/L Entry")    var        GLAcc: Record "G/L Account";        GLEntry: Record "G/L Entry";        IsHandled: Boolean;    begin        if AddCurrencyCode = '' then            exit;        TotalAddCurrAmount := TotalAddCurrAmount + GLEntry2."Additional-Currency Amount";        TotalAmount := TotalAmount + GLEntry2.Amount;        if (GenJnlLine."Additional-Currency Posting" = GenJnlLine."Additional-Currency Posting"::None) and           (TotalAmount = 0) and (TotalAddCurrAmount <> 0) and           CheckNonAddCurrCodeOccurred(GenJnlLine."Source Currency Code")        then begin            GLEntry.Init();            GLEntry.CopyFromGenJnlLine(GenJnlLine);            GLEntry."External Document No." := '';            GLEntry.Description :=              CopyStr(                StrSubstNo(                  ResidualRoundingErr,                  GLEntry.FieldCaption("Additional-Currency Amount")),                1, MaxStrLen(GLEntry.Description));            GLEntry."Source Type" := GLEntry."Source Type"::" ";            GLEntry."Source No." := '';            GLEntry."Job No." := '';            GLEntry.Quantity := 0;            GLEntry."Entry No." := NextEntryNo;            GLEntry."Transaction No." := NextTransactionNo;            if TotalAddCurrAmount < 0 then                GLEntry."G/L Account No." := AddCurrency."Residual Losses Account"            else                GLEntry."G/L Account No." := AddCurrency."Residual Gains Account";            GLEntry.Amount := 0;            GLEntry."System-Created Entry" := true;            GLEntry."Additional-Currency Amount" := -TotalAddCurrAmount;            GLAcc.Get(GLEntry."G/L Account No.");            GLAcc.TestField(Blocked, false);            GLAcc.TestField("Account Type", GLAcc."Account Type"::Posting);            IsHandled := false;            OnHandleAddCurrResidualGLEntryOnBeforeInsertGLEntry(GenJnlLine, GLEntry, TempGLEntryBuf, NextEntryNo, IsHandled);            if not IsHandled then                InsertGLEntry(GenJnlLine, GLEntry, false);            CheckGLAccDimError(GenJnlLine, GLEntry."G/L Account No.");            TotalAddCurrAmount := 0;        end;        OnAfterHandleAddCurrResidualGLEntry(GenJnlLine, GLEntry2);    end;    /// <summary>    /// Converts amount to additional reporting currency    /// </summary>    /// <remarks>    /// If additional reporting currency is not set, conversion is not performed.    /// </remarks>    /// <param name="AmountLCY">Amount in local currency</param>    /// <returns>Amount in additional reporting currency</returns>    procedure CalcLCYToAddCurr(AmountLCY: Decimal): Decimal    begin        if AddCurrencyCode = '' then            exit;        exit(ExchangeAmtLCYToFCY2(AmountLCY));    end;    local procedure GetCurrencyExchRate(GenJnlLine: Record "Gen. Journal Line")    var        NewCurrencyDate: Date;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetCurrencyExchRate(GenJnlLine, AddCurrencyCode, UseCurrFactorOnly, CurrencyDate, CurrencyFactor, IsHandled);        if IsHandled then            exit;        if AddCurrencyCode = '' then            exit;        AddCurrency.Get(AddCurrencyCode);        AddCurrency.TestField("Amount Rounding Precision");        AddCurrency.TestField("Residual Gains Account");        AddCurrency.TestField("Residual Losses Account");        NewCurrencyDate := GenJnlLine."Posting Date";        if GenJnlLine."Reversing Entry" then            NewCurrencyDate := NewCurrencyDate - 1;        OnGetCurrencyExchRateOnAfterSetNewCurrencyDate(GenJnlLine, NewCurrencyDate);        if (NewCurrencyDate <> CurrencyDate) or           UseCurrFactorOnly        then begin            UseCurrFactorOnly := false;            CurrencyDate := NewCurrencyDate;            CurrencyFactor :=              CurrExchRate.ExchangeRate(CurrencyDate, AddCurrencyCode);        end;        if (GenJnlLine."FA Add.-Currency Factor" <> 0) and           (GenJnlLine."FA Add.-Currency Factor" <> CurrencyFactor)        then begin            UseCurrFactorOnly := true;            CurrencyDate := 0D;            CurrencyFactor := GenJnlLine."FA Add.-Currency Factor";        end;        OnAfterGetCurrencyExchRate(GenJnlLine, NewCurrencyDate, CurrencyDate, UseCurrFactorOnly, CurrencyFactor);    end;    /// <summary>    /// Converts amount from local to foreign currency.    /// </summary>    /// <param name="Amount">Amount to be converted</param>    /// <returns>Amount in foreign currency</returns>    procedure ExchangeAmtLCYToFCY2(Amount: Decimal): Decimal    begin        if UseCurrFactorOnly then            exit(              Round(                CurrExchRate.ExchangeAmtLCYToFCYOnlyFactor(Amount, CurrencyFactor),                AddCurrency."Amount Rounding Precision"));        exit(          Round(            CurrExchRate.ExchangeAmtLCYToFCY(              CurrencyDate, AddCurrencyCode, Amount, CurrencyFactor),            AddCurrency."Amount Rounding Precision"));    end;    /// <summary>    /// Checks and returns if the currency code is different than additional reporting currency    /// </summary>    /// <param name="CurrencyCode">Currency Code to be checked</param>    /// <returns>True if Currency Code passed as a parameter is different than additional reporting currency</returns>    procedure CheckNonAddCurrCodeOccurred(CurrencyCode: Code[10]): Boolean    begin        NonAddCurrCodeOccured :=          NonAddCurrCodeOccured or (AddCurrencyCode <> CurrencyCode);        exit(NonAddCurrCodeOccured);    end;    local procedure TotalVATAmountOnJnlLines(GenJnlLine: Record "Gen. Journal Line") TotalVATAmount: Decimal    var        GenJnlLine2: Record "Gen. Journal Line";    begin        GenJnlLine2.SetRange("Source Code", GenJnlLine."Source Code");        GenJnlLine2.SetRange("Document No.", GenJnlLine."Document No.");        GenJnlLine2.SetRange("Posting Date", GenJnlLine."Posting Date");        GenJnlLine2.CalcSums(GenJnlLine2."VAT Amount (LCY)", GenJnlLine2."Bal. VAT Amount (LCY)");        TotalVATAmount := GenJnlLine2."VAT Amount (LCY)" - GenJnlLine2."Bal. VAT Amount (LCY)";        exit(TotalVATAmount);    end;    /// <summary>    /// Sets parameter ReverseGLReg to the same value as global variable GLReg with reversed set to true.    /// </summary>    /// <remarks>    /// Global variable GLReg stores information of the g/l register that being created    /// </remarks>    /// <param name="ReverseGLReg">Return Value: General ledger register to be reversed</param>    procedure SetGLRegReverse(var ReverseGLReg: Record "G/L Register")    begin        GLReg.Reversed := true;        ReverseGLReg := GLReg;    end;    local procedure InsertVATEntriesFromTemp(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GLEntry: Record "G/L Entry")    var        Complete: Boolean;        LinkedAmount: Decimal;        FirstEntryNo: Integer;        LastEntryNo: Integer;    begin        TempVATEntry.Reset();        TempVATEntry.SetRange("Gen. Bus. Posting Group", GLEntry."Gen. Bus. Posting Group");        TempVATEntry.SetRange("Gen. Prod. Posting Group", GLEntry."Gen. Prod. Posting Group");        TempVATEntry.SetRange("VAT Bus. Posting Group", GLEntry."VAT Bus. Posting Group");        TempVATEntry.SetRange("VAT Prod. Posting Group", GLEntry."VAT Prod. Posting Group");        case DtldCVLedgEntryBuf."Entry Type" of            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Excl.)":                begin                    FirstEntryNo := 1000000;                    LastEntryNo := 1999999;                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Excl.)":                begin                    FirstEntryNo := 2000000;                    LastEntryNo := 2999999;                end;            DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Excl.)":                begin                    FirstEntryNo := 3000000;                    LastEntryNo := 3999999;                end;        end;        TempVATEntry.SetRange("Entry No.", FirstEntryNo, LastEntryNo);        if TempVATEntry.FindSet() then            repeat                VATEntry := TempVATEntry;                VATEntry."Entry No." := NextVATEntryNo;                VATEntry."G/L Register No." := GLReg."No.";                VATEntry.TestField("G/L Register No.");                OnInsertVATEntriesFromTempOnBeforeVATEntryInsert(VATEntry, TempVATEntry, GLReg, GLEntry);                VATEntry.Insert(true);                NextVATEntryNo := NextVATEntryNo + 1;                if VATEntry."Unrealized VAT Entry No." = 0 then                    TempGLEntryVATEntryLink.InsertLinkSelf(GLEntry."Entry No.", VATEntry."Entry No.");                LinkedAmount += VATEntry.Amount + VATEntry.Base;                Complete := LinkedAmount = -(DtldCVLedgEntryBuf."Amount (LCY)" + DtldCVLedgEntryBuf."VAT Amount (LCY)");                LastEntryNo := TempVATEntry."Entry No.";            until Complete or (TempVATEntry.Next() = 0);        TempVATEntry.SetRange("Entry No.", FirstEntryNo, LastEntryNo);        TempVATEntry.DeleteAll();    end;    /// <summary>    /// Returns smaller value of the two parameters passed to the procedure.    /// </summary>    /// <param name="Decimal1">Value to compare</param>    /// <param name="Decimal2">Value to compare</param>    /// <returns>Smaller of the two passed parameters</returns>    procedure ABSMin(Decimal1: Decimal; Decimal2: Decimal): Decimal    begin        if Abs(Decimal1) < Abs(Decimal2) then            exit(Decimal1);        exit(Decimal2);    end;    local procedure GetApplnRoundPrecision(NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"): Decimal    var        ApplnCurrency: Record Currency;    begin        if NewCVLedgEntryBuf."Currency Code" = OldCVLedgEntryBuf."Currency Code" then            exit(0);        ApplnCurrency.Initialize(NewCVLedgEntryBuf."Currency Code");        if NewCVLedgEntryBuf."Currency Code" <> '' then            exit(ApplnCurrency."Appln. Rounding Precision");        GetGLSetup();        exit(GLSetup."Appln. Rounding Precision");    end;    /// <summary>    /// Retrieves general ledger setup if it wasn't retrieved before.    /// Global variable to store additional reporting currency is set from general ledger setup.    /// </summary>    procedure GetGLSetup()    begin        if GLSetupRead then            exit;        GLSetup.Get();        GLSetupRead := true;        AddCurrencyCode := GLSetup."Additional Reporting Currency";        OnAfterGetGLSetup(GLSetup, GLSetupRead, AddCurrencyCode);    end;    local procedure ReadGLSetup(var NewGLSetup: Record "General Ledger Setup")    begin        NewGLSetup := GLSetup;    end;    /// <summary>    /// Retrieves and caches the source code setup for posting operations.    /// Optimizes performance by reading the setup once and reusing it across posting operations.    /// </summary>    procedure GetSourceCodeSetup()    begin        if SourceCodeSetupRead then            exit;        SourceCodeSetup.Get();        SourceCodeSetupRead := true;    end;    local procedure CheckSalesExtDocNo(GenJnlLine: Record "Gen. Journal Line")    var        SalesSetup: Record "Sales & Receivables Setup";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckSalesExtDocNo(GenJnlLine, IsHandled);        if IsHandled then            exit;        SalesSetup.Get();        if not SalesSetup."Ext. Doc. No. Mandatory" then            exit;        if GenJnlLine."Document Type" in           [GenJnlLine."Document Type"::Invoice,            GenJnlLine."Document Type"::"Credit Memo",            GenJnlLine."Document Type"::Payment,            GenJnlLine."Document Type"::Refund,            GenJnlLine."Document Type"::" "]        then            GenJnlLine.TestField("External Document No.");    end;    local procedure CheckPurchExtDocNo(GenJnlLine: Record "Gen. Journal Line")    var        PurchSetup: Record "Purchases & Payables Setup";        OldVendLedgEntry: Record "Vendor Ledger Entry";        VendorMgt: Codeunit "Vendor Mgt.";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckPurchExtDocNoProcedure(GenJnlLine, IsHandled);        if IsHandled then            exit;        PurchSetup.Get();        if not (PurchSetup."Ext. Doc. No. Mandatory" or (GenJnlLine."External Document No." <> '')) then            exit;        GenJnlLine.TestField("External Document No.");        OldVendLedgEntry.Reset();        VendorMgt.SetFilterForExternalDocNo(          OldVendLedgEntry, GenJnlLine."Document Type", GenJnlLine."External Document No.",          GenJnlLine."Account No.", GenJnlLine."Document Date");        if not OldVendLedgEntry.IsEmpty() then            Error(              PurchaseAlreadyExistsErr,              GenJnlLine."Document Type", GenJnlLine."External Document No.");    end;    /// <summary>    /// Check dimension restrictions on gen. journal line that relates to g/l account.    /// </summary>    /// <remarks>    /// Only gen. journal lines that have amount are checked    /// FA Posting Type must be equal to disposal on gen. journal line    /// </remarks>    /// <param name="GenJnlLine">gen. journal line being posted</param>    /// <param name="GLAccNo">g/l account no. to be checked</param>    procedure CheckDimValueForDisposal(GenJnlLine: Record "Gen. Journal Line"; AccountNo: Code[20])    var        DimMgt: Codeunit DimensionManagement;        TableID: array[10] of Integer;        AccNo: array[10] of Code[20];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckDimValueForDisposal(GenJnlLine, AccountNo, IsHandled);        if IsHandled then            exit;        if ((GenJnlLine.Amount = 0) or (GenJnlLine."Amount (LCY)" = 0)) and           (GenJnlLine."FA Posting Type" = GenJnlLine."FA Posting Type"::Disposal)        then begin            TableID[1] := DimMgt.TypeToTableID1(GenJnlLine."Account Type"::"G/L Account".AsInteger());            AccNo[1] := AccountNo;            if not DimMgt.CheckDimValuePosting(TableID, AccNo, GenJnlLine."Dimension Set ID") then                Error(DimMgt.GetDimValuePostingErr());        end;    end;    /// <summary>    /// Sets the global variable OverrideDimErr for the current instance of the codeunit.    /// If OverrideDimErr is not set dimension check is performed before posting gen. journal line     /// </summary>    procedure SetOverDimErr()    begin        OverrideDimErr := true;    end;    /// <summary>    /// Sets the Preview Mode for the current instance of the codeunit.    /// Preview Mode ensures no transactions are committed to the database.    /// </summary>    /// <param name="NewPreviewMode">The new value for the Preview Mode.</param>    procedure SetPreviewMode(NewPreviewMode: Boolean)    begin        PreviewMode := NewPreviewMode;    end;    /// <summary>    /// Check dimension restrictions on gen. journal line that relates to g/l account.    /// </summary>    /// <remarks>    /// Only gen. journal lines that have amount and currency are checked    /// g/l account must be same as specified on currency realized/unrealized gain/loss    /// </remarks>    /// <param name="GenJnlLine">gen. journal line being posted</param>    /// <param name="GLAccNo">g/l account no. to be checked</param>    procedure CheckGLAccDimError(GenJnlLine: Record "Gen. Journal Line"; GLAccNo: Code[20])    var        DimMgt: Codeunit DimensionManagement;        TableID: array[10] of Integer;        AccNo: array[10] of Code[20];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckGLAccDimError(GenJnlLine, GLAccNo, IsHandled);        if IsHandled then            exit;        if ((GenJnlLine.Amount = 0) and (GenJnlLine."Amount (LCY)" = 0)) and (not IsGainLossAccount(GenJnlLine."Source Currency Code", GLAccNo)) then            exit;        TableID[1] := DATABASE::"G/L Account";        AccNo[1] := GLAccNo;        if DimMgt.CheckDimValuePosting(TableID, AccNo, GenJnlLine."Dimension Set ID") then begin            OnAfterCheckGLAccDimError(GenJnlLine);            exit;        end;        if GenJnlLine."Line No." <> 0 then            Error(              DimensionUsedErr,              GenJnlLine.TableCaption(), GenJnlLine."Journal Template Name",              GenJnlLine."Journal Batch Name", GenJnlLine."Line No.",              DimMgt.GetDimValuePostingErr());        Error(DimMgt.GetDimValuePostingErr());    end;    /// <summary>    /// Sets the global variable IgnoreJournalTemplNameMandatoryCheck for the current instance of the codeunit.    /// If IgnoreJournalTemplNameMandatoryCheck is not set "Journal Templ. Name Mandatory" check is performed before gen. journal line     /// </summary>    procedure SetIgnoreJournalTemplNameMandatoryCheck()    begin        IgnoreJournalTemplNameMandatoryCheck := true;    end;    local procedure IsGainLossAccount(CurrencyCode: Code[10]; GLAccNo: Code[20]): Boolean    var        Currency: Record Currency;    begin        if CurrencyCode = '' then            CurrencyCode := ApplyingCurrencyCode;        if CurrencyCode = '' then            exit(false);        if not Currency.Get(CurrencyCode) then            exit(false);        case true of            Currency."Realized Gains Acc." = GLAccNo,            Currency."Realized Losses Acc." = GLAccNo,            Currency."Unrealized Gains Acc." = GLAccNo,            Currency."Unrealized Losses Acc." = GLAccNo:                exit(true);        end;    end;    local procedure CheckGLAccDirectPosting(GenJnlLine: Record "Gen. Journal Line"; GLAcc: Record "G/L Account")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckGLAccDirectPosting(GenJnlLine, GLAcc, IsHandled);        if IsHandled then            exit;        if not GenJnlLine."System-Created Entry" then            if GenJnlLine."Posting Date" = NormalDate(GenJnlLine."Posting Date") then                GLAcc.TestField("Direct Posting", true);    end;    local procedure CalculateCurrentBalance(AccountNo: Code[20]; BalAccountNo: Code[20]; InclVATAmount: Boolean; AmountLCY: Decimal; VATAmount: Decimal)    begin        if (AccountNo <> '') and (BalAccountNo <> '') then            exit;        if AccountNo = BalAccountNo then            exit;        if not InclVATAmount then            VATAmount := 0;        if BalAccountNo <> '' then            CurrentBalance -= AmountLCY + VATAmount        else            CurrentBalance += AmountLCY + VATAmount;    end;    /// <summary>    /// Retrieves currency record based on the currency code.    /// </summary>    /// <param name="Currency">Return Value: Currency record</param>    /// <param name="CurrencyCode">Currency code for record to be retrieved</param>    procedure GetCurrency(var Currency: Record Currency; CurrencyCode: Code[10])    begin        if Currency.Code <> CurrencyCode then            if CurrencyCode = '' then                Clear(Currency)            else                Currency.Get(CurrencyCode);    end;    local procedure GetSourceCurrency(CurrencyCode: Code[10]): Decimal    var        Currency: Record Currency;    begin        if CurrencyCode = '' then            Currency.InitRoundingPrecision()        else begin            Currency.Get(CurrencyCode);            Currency.TestField("Amount Rounding Precision");        end;        exit(Currency."Amount Rounding Precision");    end;    /// <summary>    /// Populates the array AdjAmount with gen. journal lines value amount and additional currency amount.    /// </summary>    /// <remarks>    /// If amount and additional currency amount values are positive array elements 1 (one) and 2 (two) are populated.    /// For negative values array elements 3 (three) and 4 (four) are populated    /// </remarks>    /// <param name="AdjAmount">Return Value: array of adjustment amounts</param>    /// <param name="Amount">Gen. journal line amount</param>    /// <param name="AmountAddCurr">Gen. journal line amount in additional currency</param>    procedure CollectAdjustment(var AdjAmount: array[4] of Decimal; Amount: Decimal; AmountAddCurr: Decimal)    var        Offset: Integer;    begin        Offset := GetAdjAmountOffset(Amount, AmountAddCurr);        AdjAmount[Offset] += Amount;        AdjAmount[Offset + 1] += AmountAddCurr;    end;    /// <summary>    /// Handles detailed adjustment entries for currency and rounding differences in posting.    /// Creates additional G/L entries to balance out adjustment amounts from currency conversions and rounding.    /// </summary>    /// <param name="GenJnlLine">General journal line being processed</param>    /// <param name="GLEntry">G/L entry being adjusted</param>    /// <param name="AdjAmount">Array of adjustment amounts for different currencies and scenarios</param>    /// <param name="TotalAmountLCY">Total amount in local currency for validation</param>    /// <param name="TotalAmountAddCurr">Total amount in additional currency for validation</param>    /// <param name="GLAccNo">G/L account number for adjustment entries</param>    procedure HandleDtldAdjustment(GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; AdjAmount: array[4] of Decimal; TotalAmountLCY: Decimal; TotalAmountAddCurr: Decimal; GLAccNo: Code[20])    var        IsHandled: Boolean;    begin        if not PostDtldAdjustment(             GenJnlLine, GLEntry, AdjAmount,             TotalAmountLCY, TotalAmountAddCurr, GLAccNo,             GetAdjAmountOffset(TotalAmountLCY, TotalAmountAddCurr))        then begin            IsHandled := false;            OnHandleDtldAdjustmentOnBeforeInitGLEntry(GenJnlLine, GLEntry, TotalAmountLCY, TotalAmountAddCurr, GLAccNo, IsHandled);            if not IsHandled then                if GenJnlLine."Source Currency Code" = AddCurrencyCode then                    InitGLEntry(                        GenJnlLine, GLEntry, GLAccNo, TotalAmountLCY, TotalAmountAddCurr, true, true, TotalAmountAddCurr)                else                    InitGLEntry(                        GenJnlLine, GLEntry, GLAccNo, TotalAmountLCY, 0, false, true, TotalAmountAddCurr);        end;    end;    local procedure PostDtldAdjustment(GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; AdjAmount: array[4] of Decimal; TotalAmountLCY: Decimal; TotalAmountAddCurr: Decimal; GLAcc: Code[20]; ArrayIndex: Integer): Boolean    var        IsHandled: Boolean;    begin        if (GenJnlLine."Bal. Account No." <> '') and           ((AdjAmount[ArrayIndex] <> 0) or (AdjAmount[ArrayIndex + 1] <> 0)) and           ((TotalAmountLCY + AdjAmount[ArrayIndex] <> 0) or (TotalAmountAddCurr + AdjAmount[ArrayIndex + 1] <> 0))        then begin            IsHandled := false;            OnPostDtldAdjustmentOnBeforeCreateGLEntryBalAcc(GenJnlLine, GLAcc, AdjAmount, ArrayIndex, IsHandled, NextEntryNo);            if not IsHandled then begin                GenJnlLine."Zero Src. Curr. Amount" := true;                CreateGLEntryBalAcc(                    GenJnlLine, GLAcc, -AdjAmount[ArrayIndex], -AdjAmount[ArrayIndex + 1],                    GenJnlLine."Bal. Account Type", GenJnlLine."Bal. Account No.");                GenJnlLine."Zero Src. Curr. Amount" := false;            end;            InitGLEntry(                GenJnlLine, GLEntry, GLAcc, TotalAmountLCY + AdjAmount[ArrayIndex],                TotalAmountAddCurr + AdjAmount[ArrayIndex + 1], true, true, TotalAmountAddCurr);            AdjAmount[ArrayIndex] := 0;            AdjAmount[ArrayIndex + 1] := 0;            exit(true);        end;        exit(false);    end;    /// <summary>    /// Returns offset of adjustment amount.    /// If amount positive and amount in additional currency is greater than 0 (zero) return value will be 1. If not - return value will be 3.    /// </summary>    /// <param name="Amount">gen. journal line amount</param>    /// <param name="AmountACY">gen. journal amount (in additional currency)</param>    /// <returns>Adjustment amount offset</returns>    procedure GetAdjAmountOffset(Amount: Decimal; AmountACY: Decimal): Integer    begin        if (Amount > 0) or (Amount = 0) and (AmountACY > 0) then            exit(1);        exit(3);    end;    /// <summary>    /// Returns next entry no. that should be used when creating ledger (i.e. general, customer, vendor, etc.) entries.    /// </summary>    /// <returns>Returns next entry no. to be used for posting</returns>    procedure GetNextEntryNo(): Integer    begin        exit(NextEntryNo);    end;    /// <summary>    /// Returns next transaction no. that should be used when creating ledger (i.e. general, customer, vendor, etc.) entries.    /// </summary>    /// <returns>Returns next transaction no. to be used for posting</returns>    procedure GetNextTransactionNo(): Integer    begin        exit(NextTransactionNo);    end;    /// <summary>    /// Return next vat entry no. that should be used when creating next vat entry.    /// </summary>    /// <returns>Next vat entry no. to be used for posting</returns>    procedure GetNextVATEntryNo(): Integer    begin        exit(NextVATEntryNo);    end;    /// <summary>    /// Increases global variable NextVATEntryNo by 1 (one).    /// </summary>    /// <remarks>    /// Variable NextVATEntryNo is used as entry no. when creating vat entries    /// </remarks>    procedure IncrNextVATEntryNo()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeIncrNextVATEntryNo(NextVATEntryNo, IsHandled);        if IsHandled then            exit;        NextVATEntryNo := NextVATEntryNo + 1;    end;    /// <summary>    /// Increases global variable NextEntryNo by 1 (one).    /// </summary>    /// <remarks>    /// Variable NextEntryNo is used as entry no. when creating ledger entries    /// </remarks>    procedure IncrNextEntryNo()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeIncrNextEntryNo(NextEntryNo, IsHandled);        if IsHandled then            exit;        NextEntryNo := NextEntryNo + 1;    end;    local procedure IsNotPayment(DocumentType: Enum "Gen. Journal Document Type") Result: Boolean    begin        Result := DocumentType in [DocumentType::Invoice,                              DocumentType::"Credit Memo",                              DocumentType::"Finance Charge Memo",                              DocumentType::Reminder];        OnAfterIsNotPayment(DocumentType, Result);    end;    /// <summary>    /// Procedure to check if global temporary/buffer table TempGLEntryBuf is empty.    /// </summary>    /// <returns>True if global temporary/buffer table TempGLEntryBuf is empty</returns>    procedure IsTempGLEntryBufEmpty(): Boolean    begin        exit(TempGLEntryBuf.IsEmpty);    end;    local procedure IsVATAdjustment(EntryType: Enum "Detailed CV Ledger Entry Type"): Boolean    var        DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer";    begin        exit(EntryType in [DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Adjustment)",                           DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Adjustment)",                           DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Adjustment)"]);    end;    local procedure IsVATExcluded(EntryType: Enum "Detailed CV Ledger Entry Type"): Boolean    var        DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer";    begin        exit(EntryType in [DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Excl.)",                           DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Excl.)",                           DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Excl.)"]);    end;    local procedure UpdateVATEntryTaxDetails(GenJnlLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry"; TaxDetail: Record "Tax Detail"; var TaxJurisdiction: Record "Tax Jurisdiction")    begin        if TaxDetail."Tax Jurisdiction Code" <> '' then            TaxJurisdiction.Get(TaxDetail."Tax Jurisdiction Code");        if GenJnlLine."Gen. Posting Type" <> GenJnlLine."Gen. Posting Type"::Settlement then begin            VATEntry."Tax Group Used" := TaxDetail."Tax Group Code";            VATEntry."Tax Type" := TaxDetail."Tax Type";            VATEntry."Tax on Tax" := TaxDetail."Calculate Tax on Tax";        end;        VATEntry."Tax Jurisdiction Code" := TaxDetail."Tax Jurisdiction Code";        OnAfterUpdateVATEntryTaxDetails(VATEntry, TaxDetail);    end;    /// <summary>    /// Parameter GLEntryNo is updated with value of parameter SavedEntryNo.    /// Global variable NextEntryNo is decreased by 1 (one).    /// </summary>    /// <remarks>    /// Variable NextEntryNo is used as entry no. when creating ledger entries    /// </remarks>    /// <param name="ExistingGLEntryNo">Existing value for g/l entry no.</param>    /// <param name="SavedEntryNo">New value for g/l entry no.</param>    procedure UpdateGLEntryNo(var ExistingGLEntryNo: Integer; var SavedEntryNo: Integer)    begin        if SavedEntryNo <> 0 then begin            ExistingGLEntryNo := SavedEntryNo;            NextEntryNo := NextEntryNo - 1;            SavedEntryNo := 0;        end;    end;    /// <summary>    /// Creates/updates temporary/buffer table TempDimPostingBuffer with amount and amount in additional currency based on dimension set id.    /// The procedure should be used to aggregate amounts by dimensions.    /// </summary>    /// <param name="TempDimPostingBuffer">Return Value: temporary buffer table to store amounts based on dimension set id.</param>    /// <param name="DimSetID">Dimension set id of the transaction</param>    /// <param name="DtldCVLedgEntryBuf">Buffer table for detailed customer/vendor ledger entries to be posted.</param>    procedure UpdateTotalAmounts(var TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary; DimSetID: Integer; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    var        IsHandled: Boolean;    begin        OnBeforeUpdateTotalAmountsV19(          TempDimPostingBuffer, DimSetID, DtldCVLedgEntryBuf."Amount (LCY)", DtldCVLedgEntryBuf."Additional-Currency Amount", IsHandled,          DtldCVLedgEntryBuf);        if IsHandled then            exit;        TempDimPostingBuffer.SetRange(TempDimPostingBuffer."Dimension Set ID", DimSetID);        if TempDimPostingBuffer.FindFirst() then begin            TempDimPostingBuffer.Amount += DtldCVLedgEntryBuf."Amount (LCY)";            TempDimPostingBuffer."Amount (ACY)" += DtldCVLedgEntryBuf."Additional-Currency Amount";            TempDimPostingBuffer.Modify();        end else begin            TempDimPostingBuffer.Init();            TempDimPostingBuffer."Dimension Set ID" := DimSetID;            TempDimPostingBuffer.Amount := DtldCVLedgEntryBuf."Amount (LCY)";            TempDimPostingBuffer."Amount (ACY)" := DtldCVLedgEntryBuf."Additional-Currency Amount";            TempDimPostingBuffer.Insert();        end;        OnAfterUpdateTotalAmounts(TempDimPostingBuffer, DtldCVLedgEntryBuf);    end;    local procedure CreateGLEntriesForTotalAmountsUnapply(GenJnlLine: Record "Gen. Journal Line"; var TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary; GLAccNo: Code[20])    var        DimMgt: Codeunit DimensionManagement;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreateGLEntriesForTotalAmountsUnapplyProcedure(GenJnlLine, TempDimPostingBuffer, GLAccNo, IsHandled);        if IsHandled then            exit;        TempDimPostingBuffer.SetRange(TempDimPostingBuffer."Dimension Set ID");        if TempDimPostingBuffer.FindSet() then            repeat                if (TempDimPostingBuffer.Amount <> 0) or                   (TempDimPostingBuffer."Amount (ACY)" <> 0) and (GLSetup."Additional Reporting Currency" <> '')                then begin                    IsHandled := false;                    OnCreateGLEntriesForTotalAmountsUnapplyOnBeforeUpdateGenJnlLineDim(IsHandled);                    if not IsHandled then                        DimMgt.UpdateGenJnlLineDim(GenJnlLine, TempDimPostingBuffer."Dimension Set ID");                    OnCreateGLEntriesForTotalAmountsUnapplyOnBeforeCreateGLEntryV19(GenJnlLine, TempDimPostingBuffer, GLAccNo);                    CreateGLEntry(                        GenJnlLine, GLAccNo, TempDimPostingBuffer.Amount, TempDimPostingBuffer."Amount (ACY)", true, 0);                end;            until TempDimPostingBuffer.Next() = 0;    end;    local procedure CreateGLEntriesForTotalAmounts(GenJnlLine: Record "Gen. Journal Line"; var TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary; AdjAmountBuf: array[4] of Decimal; SavedEntryNo: Integer; GLAccNo: Code[20]; LedgEntryInserted: Boolean)    var        DimMgt: Codeunit DimensionManagement;        GLEntryInserted: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreateGLEntriesForTotalAmountsV19(TempDimPostingBuffer, GenJnlLine, GLAccNo, IsHandled, AdjAmountBuf, SavedEntryNo, LedgEntryInserted);        if IsHandled then            exit;        GLEntryInserted := false;        TempDimPostingBuffer.Reset();        if TempDimPostingBuffer.FindSet() then            repeat                if (TempDimPostingBuffer.Amount <> 0) or (TempDimPostingBuffer."Amount (ACY)" <> 0) and (AddCurrencyCode <> '') then begin                    IsHandled := false;                    OnCreateGLEntriesForTotalAmountsOnBeforeUpdateGenJnlLineDim(IsHandled);                    if not IsHandled then                        DimMgt.UpdateGenJnlLineDim(GenJnlLine, TempDimPostingBuffer."Dimension Set ID");                    OnBeforeCreateGLEntryForTotalAmountsForDimPostBuf(GenJnlLine, TempDimPostingBuffer, GLAccNo);                    CreateGLEntryForTotalAmounts(GenJnlLine, TempDimPostingBuffer.Amount, TempDimPostingBuffer."Amount (ACY)", AdjAmountBuf, SavedEntryNo, GLAccNo);                    GLEntryInserted := true;                end;            until TempDimPostingBuffer.Next() = 0;        if not GLEntryInserted and LedgEntryInserted then            CreateGLEntryForTotalAmounts(GenJnlLine, 0, 0, AdjAmountBuf, SavedEntryNo, GLAccNo);    end;    local procedure CreateGLEntryForTotalAmounts(GenJnlLine: Record "Gen. Journal Line"; Amount: Decimal; AmountACY: Decimal; AdjAmountBuf: array[4] of Decimal; var SavedEntryNo: Integer; GLAccNo: Code[20])    var        GLEntry: Record "G/L Entry";        IsHandled: Boolean;    begin        HandleDtldAdjustment(GenJnlLine, GLEntry, AdjAmountBuf, Amount, AmountACY, GLAccNo);        GLEntry."Bal. Account Type" := GenJnlLine."Bal. Account Type";        GLEntry."Bal. Account No." := GenJnlLine."Bal. Account No.";        UpdateGLEntryNo(GLEntry."Entry No.", SavedEntryNo);        IsHandled := false;        OnCreateGLEntryForTotalAmountsOnBeforeInsertGLEntry(GenJnlLine, GLEntry, IsHandled, TempGLEntryVATEntryLink);        if IsHandled then            exit;        InsertGLEntry(GenJnlLine, GLEntry, true);    end;    /// <summary>    /// Posts the extra derogatory depreciation created when acquisition cost is depreciated.    /// FAJnlPostLine.PostDerogatoryCounterpart() copies the acquisition cost to the linked derogatory book.    /// This extra amount must be calculated because the acquisition line contains cost, not depreciation.    /// </summary>    /// <param name="SourceGenJournalLine">The acquisition-cost general journal line used to prepare the adjustment.</param>    local procedure CreateAndPostDerogEntry(SourceGenJournalLine: Record "Gen. Journal Line")    var        GenJnlLine: Record "Gen. Journal Line";        FAJnlLine: Record "FA Journal Line";        DerogFALedgerEntry: Record "FA Ledger Entry";        DerogatoryPostingMgt: Codeunit "Derogatory Posting Mgt.";        IntegrationGLDerogatory: Boolean;    begin        if not DerogatoryPostingMgt.PrepareAcquisitionCostAdjustment(             GenJnlLine, SourceGenJournalLine, IntegrationGLDerogatory)        then            exit;        // Post through the general journal so the adjustment creates G/L entries in the current transaction.        if IntegrationGLDerogatory then begin            FAJnlPostLine.GenJnlPostLineContinue(              GenJnlLine, GenJnlLine.Amount, GenJnlLine."VAT Amount", NextTransactionNo, NextEntryNo, GLReg."No.");            DerogFALedgerEntry := FAJnlPostLine.GetLastSourceFALedgerEntry();            DerogFALedgerEntry.TestField("Entry No.");            DerogFALedgerEntry."Automatic Entry" := true;            FAJnlPostLine.InsertBalAcc(DerogFALedgerEntry);        end else begin            DerogatoryPostingMgt.MakeDerogatoryJournalLine(FAJnlLine, GenJnlLine, Enum::"Derogatory Posting Role"::Source);            FAJnlLine.Validate("Depreciation Book Code", SourceGenJournalLine."Depreciation Book Code");            FAJnlPostLine.FAJnlPostLine(FAJnlLine, true);        end;    end;    /// <summary>    /// Updates additional-currency amount on buffer table DtldCVLedgEntryBuf when un-application of customer/vendor ledger entries is posted.    /// </summary>    /// <remarks>    /// Amount is only updated for buffer table entry with type other than application, unrealized/realized gain/loss or correction of remaining amount    /// </remarks>    /// <param name="DtldCVLedgEntryBuf">Buffer table for detailed customer/vendor ledger entries to be posted.</param>    procedure SetAddCurrForUnapplication(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin        if not (DtldCVLedgEntryBuf."Entry Type" in                [DtldCVLedgEntryBuf."Entry Type"::Application, DtldCVLedgEntryBuf."Entry Type"::"Unrealized Loss",                 DtldCVLedgEntryBuf."Entry Type"::"Unrealized Gain", DtldCVLedgEntryBuf."Entry Type"::"Realized Loss",                 DtldCVLedgEntryBuf."Entry Type"::"Realized Gain", DtldCVLedgEntryBuf."Entry Type"::"Correction of Remaining Amount"])        then            if (DtldCVLedgEntryBuf."Entry Type" = DtldCVLedgEntryBuf."Entry Type"::"Appln. Rounding") or               ((AddCurrencyCode <> '') and (AddCurrencyCode = DtldCVLedgEntryBuf."Currency Code"))            then                DtldCVLedgEntryBuf."Additional-Currency Amount" := DtldCVLedgEntryBuf.Amount            else                DtldCVLedgEntryBuf."Additional-Currency Amount" := CalcAddCurrForUnapplication(DtldCVLedgEntryBuf."Posting Date", DtldCVLedgEntryBuf."Amount (LCY)");    end;    /// <summary>    /// Checks if multiple customer posting groups exists on customer ledger entries that relate to detailed entries being created.    /// </summary>    /// <remarks>    /// The check is only performed when customer ledger entries are being applied.    /// </remarks>    /// <param name="DetailedCVLedgEntryBuffer">Buffer table for detailed customer ledger entries to be posted.</param>    /// <returns>Returns true if multiple customer posting groups exists for customer ledger entries being applied</returns>    procedure CheckCustMultiplePostingGroups(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"): Boolean    var        CustLedgerEntry: Record "Cust. Ledger Entry";        PostingGroup: Code[20];        IsHandled: Boolean;        IsMultiplePostingGroups: Boolean;    begin        OnBeforeCheckCustMultiplePostingGroups(DetailedCVLedgEntryBuffer, IsMultiplePostingGroups, IsHandled);        if IsHandled then            exit(IsMultiplePostingGroups);        PostingGroup := '';        DetailedCVLedgEntryBuffer.Reset();        DetailedCVLedgEntryBuffer.SetRange("Entry Type", DetailedCVLedgEntryBuffer."Entry Type"::Application);        if DetailedCVLedgEntryBuffer.FindSet() then            repeat                CustLedgerEntry.Get(DetailedCVLedgEntryBuffer."CV Ledger Entry No.");                if (PostingGroup <> '') and (PostingGroup <> CustLedgerEntry."Customer Posting Group") then                    exit(true);                PostingGroup := CustLedgerEntry."Customer Posting Group";            until DetailedCVLedgEntryBuffer.Next() = 0;        exit(false);    end;    /// <summary>    /// Checks if multiple vendor posting groups exists on vendor ledger entries that relate to detailed entries being created.    /// </summary>    /// <remarks>    /// The check is only performed when vendor ledger entries are being applied.    /// </remarks>    /// <param name="DetailedCVLedgEntryBuffer">Buffer table for detailed vendor ledger entries to be posted.</param>    /// <returns>Returns true if multiple vendor posting groups exists for vendor ledger entries being applied</returns>    procedure CheckVendMultiplePostingGroups(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"): Boolean    var        VendorLedgerEntry: Record "Vendor Ledger Entry";        PostingGroup: Code[20];        IsHandled: Boolean;        IsMultiplePostingGroups: Boolean;    begin        OnBeforeCheckVendMultiplePostingGroups(DetailedCVLedgEntryBuffer, IsMultiplePostingGroups, IsHandled);        if IsHandled then            exit(IsMultiplePostingGroups);        PostingGroup := '';        DetailedCVLedgEntryBuffer.Reset();        DetailedCVLedgEntryBuffer.SetRange("Entry Type", DetailedCVLedgEntryBuffer."Entry Type"::Application);        if DetailedCVLedgEntryBuffer.FindSet() then            repeat                VendorLedgerEntry.Get(DetailedCVLedgEntryBuffer."CV Ledger Entry No.");                if (PostingGroup <> '') and (PostingGroup <> VendorLedgerEntry."Vendor Posting Group") then                    exit(true);                PostingGroup := VendorLedgerEntry."Vendor Posting Group";            until DetailedCVLedgEntryBuffer.Next() = 0;        exit(false);    end;    /// <summary>    /// Checks if multiple employee posting groups exists on employee ledger entries that relate to detailed entries being created.    /// </summary>    /// <remarks>    /// The check is only performed when employee ledger entries are being applied.    /// </remarks>    /// <param name="DetailedCVLedgEntryBuffer">Buffer table for detailed employee ledger entries to be posted.</param>    /// <returns>Returns true if multiple employee posting groups exists for employee ledger entries being applied</returns>    procedure CheckEmplMultiplePostingGroups(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"): Boolean    var        EmployeeLedgerEntry: Record "Employee Ledger Entry";        PostingGroup: Code[20];    begin        PostingGroup := '';        DetailedCVLedgEntryBuffer.Reset();        DetailedCVLedgEntryBuffer.SetRange("Entry Type", DetailedCVLedgEntryBuffer."Entry Type"::Application);        if DetailedCVLedgEntryBuffer.FindSet() then            repeat                EmployeeLedgerEntry.Get(DetailedCVLedgEntryBuffer."CV Ledger Entry No.");                if (PostingGroup <> '') and (PostingGroup <> EmployeeLedgerEntry."Employee Posting Group") then                    exit(true);                PostingGroup := EmployeeLedgerEntry."Employee Posting Group";            until DetailedCVLedgEntryBuffer.Next() = 0;        exit(false);    end;    local procedure CheckDetCustLedgEntryMultiplePostingGrOnBeforeUnapply(var DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry"; DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"): Boolean    var        IsHandled: Boolean;        MultiplePostingGroupsDetected: Boolean;    begin        OnBeforeCheckDetCustLedgEntryMultiplePostingGrOnBeforeUnapply(DetailedCustLedgEntry2, DetailedCustLedgEntry, MultiplePostingGroupsDetected, IsHandled);        if IsHandled then            exit(MultiplePostingGroupsDetected);        DetailedCustLedgEntry2.SetRange("Entry Type", DetailedCustLedgEntry2."Entry Type"::Application);        DetailedCustLedgEntry2.FindSet();        repeat            if DetailedCustLedgEntry2."Posting Group" <> DetailedCustLedgEntry."Posting Group" then                exit(true);        until DetailedCustLedgEntry2.Next() = 0;        exit(false);    end;    local procedure CheckDetVendLedgEntryMultiplePostingGrOnBeforeUnapply(var DetailedVendorLedgEntry2: Record "Detailed Vendor Ledg. Entry"; var DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"): Boolean    var        IsHandled: Boolean;        MultiplePostingGroupsDetected: Boolean;    begin        OnBeforeCheckDetVendLedgEntryMultiplePostingGrOnBeforeUnapply(DetailedVendorLedgEntry2, DetailedVendorLedgEntry, MultiplePostingGroupsDetected, IsHandled);        if IsHandled then            exit(MultiplePostingGroupsDetected);        DetailedVendorLedgEntry2.SetRange("Entry Type", DetailedVendorLedgEntry2."Entry Type"::Application);        DetailedVendorLedgEntry2.FindSet();        repeat            if DetailedVendorLedgEntry2."Posting Group" <> DetailedVendorLedgEntry."Posting Group" then                exit(true);        until DetailedVendorLedgEntry2.Next() = 0;        exit(false);    end;    local procedure CheckDetEmplLedgEntryMultiplePostingGrOnBeforeUnapply(var DetailedEmployeeLedgerEntry2: Record "Detailed Employee Ledger Entry"; var DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry"): Boolean    begin        DetailedEmployeeLedgerEntry2.SetRange("Entry Type", DetailedEmployeeLedgerEntry2."Entry Type"::Application);        DetailedEmployeeLedgerEntry2.FindSet();        repeat            if DetailedEmployeeLedgerEntry2."Posting Group" <> DetailedEmployeeLedgerEntry."Posting Group" then                exit(true);        until DetailedEmployeeLedgerEntry2.Next() = 0;        exit(false);    end;    local procedure PostDeferral(var GenJournalLine: Record "Gen. Journal Line"; AccountNo: Code[20])    var        DeferralTemplate: Record "Deferral Template";        DeferralHeader: Record "Deferral Header";        DeferralLine: Record "Deferral Line";        TempDeferralLine: Record "Deferral Line" temporary;        DeferralPostingBuffer: Record "Deferral Posting Buffer";        GLEntry: Record "G/L Entry";        CurrExchRate: Record "Currency Exchange Rate";        VATPostingSetup: Record "VAT Posting Setup";        DeferralUtilities: Codeunit "Deferral Utilities";        PerPostDate: Date;        PeriodicCount: Integer;        AmtToDefer: Decimal;        AmtToDeferACY: Decimal;        EmptyDeferralLine: Boolean;        IsHandled: Boolean;        DeferralSourceCode: Code[10];        NonDeductibleVATPct: Decimal;        PositiveVATAmountRounding: Decimal;        NegativeVATAmountRounding: Decimal;        PositiveNDVATAmountRounding: Decimal;        NegativeNDVATAmountRounding: Decimal;    begin        IsHandled := false;        OnBeforePostDeferral(GenJournalLine, AccountNo, IsHandled);        if IsHandled then            exit;        if GenJournalLine."Source Type" in [GenJournalLine."Source Type"::Vendor, GenJournalLine."Source Type"::Customer] then            // Purchasing and Sales, respectively            // We can create these types directly from the GL window, need to make sure we don't already have a deferral schedule            // created for this GL Trx before handing it off to sales/purchasing subsystem            if not JournalsSourceCodesList.Contains(GenJournalLine."Source Code") then begin                PostDeferralPostBuffer(GenJournalLine);                exit;            end;        if DeferralHeader.Get(DeferralDocType::"G/L", GenJournalLine."Journal Template Name", GenJournalLine."Journal Batch Name", 0, '', GenJournalLine."Line No.") then begin            EmptyDeferralLine := false;            // Get the range of detail records for this schedule            DeferralUtilities.FilterDeferralLines(              DeferralLine, DeferralDocType::"G/L".AsInteger(), GenJournalLine."Journal Template Name", GenJournalLine."Journal Batch Name", 0, '', GenJournalLine."Line No.");            if DeferralLine.FindSet() then                repeat                    if DeferralLine.Amount = 0 then                        EmptyDeferralLine := true;                until (DeferralLine.Next() = 0) or EmptyDeferralLine;            if EmptyDeferralLine then                Error(ZeroDeferralAmtErr, GenJournalLine."Line No.", GenJournalLine."Deferral Code");            DeferralHeader."Amount to Defer (LCY)" :=                Round(CurrExchRate.ExchangeAmtFCYToLCY(GenJournalLine."Posting Date", GenJournalLine."Currency Code", DeferralHeader."Amount to Defer", GenJournalLine."Currency Factor"));            DeferralHeader.Modify();            DeferralUtilities.RoundDeferralAmount(                DeferralHeader, GenJournalLine."Currency Code", GenJournalLine."Currency Factor", GenJournalLine."Posting Date", AmtToDefer, AmtToDeferACY);        end;        DeferralTemplate.Get(GenJournalLine."Deferral Code");        DeferralTemplate.TestField("Deferral Account");        DeferralTemplate.TestField("Deferral %");        // Get the Deferral Header table so we know the amount to defer...        // Assume straight GL posting        if DeferralHeader.Get(DeferralDocType::"G/L", GenJournalLine."Journal Template Name", GenJournalLine."Journal Batch Name", 0, '', GenJournalLine."Line No.") then            // Get the range of detail records for this schedule            DeferralUtilities.FilterDeferralLines(                  DeferralLine, DeferralDocType::"G/L".AsInteger(), GenJournalLine."Journal Template Name", GenJournalLine."Journal Batch Name", 0, '', GenJournalLine."Line No.")        else            Error(NoDeferralScheduleErr, GenJournalLine."Line No.", GenJournalLine."Deferral Code");        DeferralSourceCode := GetGeneralDeferralSourceCode();        InitGLEntry(            GenJournalLine, GLEntry, AccountNo, -DeferralHeader."Amount to Defer (LCY)", -DeferralHeader."Amount to Defer", true, true,            CalcAmountSrcCurr(GenJournalLine, -DeferralHeader."Amount to Defer (LCY)"));        GLEntry.Description := SetDeferralDescription(GenJournalLine, DeferralLine, AccountNo);        GLEntry."Source Code" := DeferralSourceCode;        OnPostDeferralOnBeforeInsertGLEntryForGLAccount(GenJournalLine, DeferralLine, GLEntry, GLReg."No.");        InsertGLEntry(GenJournalLine, GLEntry, true);        InitGLEntry(            GenJournalLine, GLEntry, DeferralTemplate."Deferral Account", DeferralHeader."Amount to Defer (LCY)", DeferralHeader."Amount to Defer", true, true,            CalcAmountSrcCurr(GenJournalLine, DeferralHeader."Amount to Defer (LCY)"));        GLEntry.Description := SetDeferralDescription(GenJournalLine, DeferralLine, DeferralTemplate."Deferral Account");        GLEntry."Source Code" := DeferralSourceCode;        OnPostDeferralOnBeforeInsertGLEntryForDeferralAccount(GenJournalLine, DeferralLine, GLEntry);        InsertGLEntry(GenJournalLine, GLEntry, true);        if VATPostingSetup.Get(GenJournalLine."VAT Bus. Posting Group", GenJournalLine."VAT Prod. Posting Group") then            NonDeductibleVATPct := NonDeductibleVAT.GetNonDeductibleVATPct(GenJournalLine."VAT Bus. Posting Group", GenJournalLine."VAT Prod. Posting Group", DeferralDocType);        OnPostDeferralOnAfterGetNonDeductibleVATPct(GenJournalLine, DeferralDocType, NonDeductibleVATPct);        DeferralPostingBuffer.InitFromDeferralLine(DeferralLine);        DeferralPostingBuffer."Posting Date" := GenJournalLine."Posting Date";        DeferralPostingBuffer."G/L Account" := DeferralTemplate."Deferral Account";        DeferralPostingBuffer."Deferral Account" := AccountNo;        DeferralPostingBuffer.Description := SetDeferralDescriptionFromDeferralLine(DeferralLine, DeferralTemplate."Deferral Account");        DeferralPostingBuffer."Amount (LCY)" := DeferralHeader."Amount to Defer (LCY)";        DeferralPostingBuffer.Amount := DeferralHeader."Amount to Defer";        InsertDeferralNonDeductibleVATGLEntries(            NonDeductibleVATPct, DeferralPostingBuffer, VATPostingSetup, GenJournalLine, DeferralTemplate,            PositiveVATAmountRounding, NegativeVATAmountRounding, PositiveNDVATAmountRounding, NegativeNDVATAmountRounding);        PositiveVATAmountRounding := 0;        NegativeVATAmountRounding := 0;        PositiveNDVATAmountRounding := 0;        NegativeNDVATAmountRounding := 0;        // Here we want to get the Deferral Details table range and loop through them...        if DeferralLine.FindSet() then            repeat                TempDeferralLine := DeferralLine;                TempDeferralLine.Insert();            until DeferralLine.Next() = 0;        if TempDeferralLine.FindSet() then begin            PeriodicCount := 1;            repeat                PerPostDate := TempDeferralLine."Posting Date";                CheckDeferralPostingDate(DeferralUtilities, PerPostDate);                InitGLEntry(                    GenJournalLine, GLEntry, AccountNo, TempDeferralLine."Amount (LCY)", TempDeferralLine.Amount, true, true,                    CalcAmountSrcCurr(GenJournalLine, TempDeferralLine."Amount (LCY)"));                GLEntry."Posting Date" := PerPostDate;                GLEntry.Description := SetDeferralDescriptionFromDeferralLine(TempDeferralLine, AccountNo);                GLEntry."Source Code" := DeferralSourceCode;                OnPostDeferralOnBeforeInsertGLEntryDeferralLineForGLAccount(GenJournalLine, TempDeferralLine, GLEntry);                InsertGLEntry(GenJournalLine, GLEntry, true);                InitGLEntry(                    GenJournalLine, GLEntry, DeferralTemplate."Deferral Account", -TempDeferralLine."Amount (LCY)", -TempDeferralLine.Amount, true, true,                    CalcAmountSrcCurr(GenJournalLine, -TempDeferralLine."Amount (LCY)"));                GLEntry."Posting Date" := PerPostDate;                GLEntry.Description := SetDeferralDescriptionFromDeferralLine(TempDeferralLine, DeferralTemplate."Deferral Account");                GLEntry."Source Code" := DeferralSourceCode;                OnPostDeferralOnBeforeInsertGLEntryDeferralLineForDeferralAccount(GenJournalLine, TempDeferralLine, GLEntry);                InsertGLEntry(GenJournalLine, GLEntry, true);                DeferralPostingBuffer.InitFromDeferralLine(TempDeferralLine);                DeferralPostingBuffer."G/L Account" := AccountNo;                DeferralPostingBuffer."Deferral Account" := DeferralTemplate."Deferral Account";                DeferralPostingBuffer.Description := SetDeferralDescriptionFromDeferralLine(TempDeferralLine, DeferralTemplate."Deferral Account");                InsertDeferralNonDeductibleVATGLEntries(                    NonDeductibleVATPct, DeferralPostingBuffer, VATPostingSetup, GenJournalLine, DeferralTemplate,                    PositiveVATAmountRounding, NegativeVATAmountRounding, PositiveNDVATAmountRounding, NegativeNDVATAmountRounding);                PeriodicCount := PeriodicCount + 1;                OnPostDeferralOnAfterInsertGLEntry(GenJournalLine, TempDeferralLine);            until TempDeferralLine.Next() = 0;            OnPostDeferralOnAfterTempDeferralLineLoopCompleted(GenJournalLine, TempDeferralLine, DeferralTemplate, DeferralHeader);        end else            Error(NoDeferralScheduleErr, GenJournalLine."Line No.", GenJournalLine."Deferral Code");        OnAfterPostDeferral(GenJournalLine, TempGLEntryBuf, AccountNo);    end;    local procedure CheckDeferralPostingDate(var DeferralUtilities: Codeunit "Deferral Utilities"; PostingDate: Date)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckDeferralPostDate(PostingDate, IsHandled);        if IsHandled then            exit;        if DeferralUtilities.IsDateNotAllowed(PostingDate) then            Error(InvalidPostingDateErr, PostingDate);    end;    local procedure PostDeferralPostBuffer(GenJournalLine: Record "Gen. Journal Line")    var        DeferralPostingBuffer: Record "Deferral Posting Buffer";        GLEntry: Record "G/L Entry";        VATPostingSetup: Record "VAT Posting Setup";        DeferralTemplate: Record "Deferral Template";        NonDeductibleVATPct: Decimal;        PositiveVATAmountRounding: Decimal;        NegativeVATAmountRounding: Decimal;        PositiveNDVATAmountRounding: Decimal;        NegativeNDVATAmountRounding: Decimal;        PostDate: Date;        IsHandled: Boolean;        DeferralSourceCode: Code[10];    begin        IsHandled := false;        OnBeforePostDeferralPostBuffer(GenJournalLine, IsHandled);        if not IsHandled then begin            if GenJournalLine."Source Type" = GenJournalLine."Source Type"::Customer then begin                DeferralDocType := DeferralDocType::Sales;                DeferralSourceCode := GetSalesDeferralSourceCode();            end else begin                DeferralDocType := DeferralDocType::Purchase;                DeferralSourceCode := GetPurchaseDeferralSourceCode();            end;            DeferralPostingBuffer.SetRange("Deferral Doc. Type", DeferralDocType);            DeferralPostingBuffer.SetRange("Document No.", GenJournalLine."Document No.");            DeferralPostingBuffer.SetRange("Deferral Line No.", GenJournalLine."Deferral Line No.");            OnPostDeferralPostBufferOnAfterSetFilters(DeferralPostingBuffer, GenJournalLine, GLReg."No.", NextTransactionNo);            if VATPostingSetup.Get(GenJournalLine."VAT Bus. Posting Group", GenJournalLine."VAT Prod. Posting Group") then                NonDeductibleVATPct := NonDeductibleVAT.GetNonDeductibleVATPct(GenJournalLine."VAT Bus. Posting Group", GenJournalLine."VAT Prod. Posting Group", DeferralDocType);            if DeferralPostingBuffer.FindSet() then begin                DeferralTemplate.Get(DeferralPostingBuffer."Deferral Code");                repeat                    OnPostDeferralPostBufferOnAfterFindDeferalPostingBuffer(GenJournalLine, DeferralPostingBuffer, NonDeductibleVATPct);                    PostDate := DeferralPostingBuffer."Posting Date";                    IsHandled := false;                    OnPostDeferralPostBufferOnAfterSetPostDate(DeferralPostingBuffer, IsHandled);                    if not IsHandled then                        if DeferralUtilities.IsDateNotAllowed(PostDate) then                            Error(InvalidPostingDateErr, PostDate);                    // When no sales/purch amount is entered, the offset was already posted                    if (DeferralPostingBuffer."Sales/Purch Amount" <> 0) or (DeferralPostingBuffer."Sales/Purch Amount (LCY)" <> 0) then begin                        InitGLEntry(                            GenJournalLine, GLEntry, DeferralPostingBuffer."G/L Account",                            DeferralPostingBuffer."Sales/Purch Amount (LCY)", DeferralPostingBuffer."Sales/Purch Amount", true, true,                            CalcAmountSrcCurr(GenJournalLine, DeferralPostingBuffer."Sales/Purch Amount (LCY)"));                        GLEntry."Posting Date" := PostDate;                        GLEntry.Description := SetDeferralDescriptionFromDeferralPostingBuffer(DeferralPostingBuffer, DeferralPostingBuffer."G/L Account");                        GLEntry.CopyFromDeferralPostBuffer(DeferralPostingBuffer);                        if IsNonDeferredRemainderEntry(DeferralPostingBuffer) then                            GLEntry."Source Code" := GenJournalLine."Source Code"                        else                            GLEntry."Source Code" := DeferralSourceCode;                        OnPostDeferralPostBufferOnBeforeInsertGLEntryForGLAccount(GenJournalLine, DeferralPostingBuffer, GLEntry);                        InsertGLEntry(GenJournalLine, GLEntry, true);                    end;                    if DeferralPostingBuffer.Amount <> 0 then begin                        InitGLEntry(                            GenJournalLine, GLEntry, DeferralPostingBuffer."Deferral Account",                            -DeferralPostingBuffer."Amount (LCY)", -DeferralPostingBuffer.Amount, true, true,                            CalcAmountSrcCurr(GenJournalLine, -DeferralPostingBuffer."Amount (LCY)"));                        GLEntry."Posting Date" := PostDate;                        GLEntry.Description := SetDeferralDescriptionFromDeferralPostingBuffer(DeferralPostingBuffer, DeferralPostingBuffer."Deferral Account");                        GLEntry."Source Code" := DeferralSourceCode;                        OnPostDeferralPostBufferOnBeforeInsertGLEntryForDeferralAccount(GenJournalLine, DeferralPostingBuffer, GLEntry);                        InsertGLEntry(GenJournalLine, GLEntry, true);                        OnPostDeferralPostBufferOnAfterInsertGLEntry(GenJournalLine, DeferralPostingBuffer);                    end;                    InsertDeferralNonDeductibleVATGLEntries(                        NonDeductibleVATPct, DeferralPostingBuffer, VATPostingSetup, GenJournalLine, DeferralTemplate,                        PositiveVATAmountRounding, NegativeVATAmountRounding, PositiveNDVATAmountRounding, NegativeNDVATAmountRounding);                until DeferralPostingBuffer.Next() = 0;                OnPostDeferralPosBufferOnBeforeDeleteDeferralPostBuffer(GenJournalLine, DeferralPostingBuffer);                DeferralPostingBuffer.DeleteAll();            end;        end;        OnAfterPostDeferralPostBuffer(GenJournalLine);    end;    /// <summary>    /// Removes deferral header and line associated with gen. journal line.    /// </summary>    /// <remarks>    /// Deferrals are only removed if line no. on gen. journal line is specified (not 0).    /// </remarks>    /// <param name="GenJournalLine">General journal line that is being be posted.</param>    procedure RemoveDeferralSchedule(GenJournalLine: Record "Gen. Journal Line")    var        DeferralUtilities: Codeunit "Deferral Utilities";    begin        // Removing deferral schedule after all deferrals for this line have been posted successfully        DeferralUtilities.DeferralCodeOnDelete(            Enum::"Deferral Document Type"::"G/L".AsInteger(),            GenJournalLine."Journal Template Name", GenJournalLine."Journal Batch Name", 0, '', GenJournalLine."Line No.");    end;    local procedure InsertDeferralNonDeductibleVATGLEntries(NonDeductibleVATPct: Decimal; DeferralPostingBuffer: Record "Deferral Posting Buffer"; VATPostingSetup: Record "VAT Posting Setup"; GenJournalLine: Record "Gen. Journal Line"; DeferralTemplate: Record "Deferral Template"; var PositiveVATAmountRounding: Decimal; var NegativeVATAmountRounding: Decimal; var PositiveNDVATAmountRounding: Decimal; var NegativeNDVATAmountRounding: Decimal)    var        GLEntry: Record "G/L Entry";        NonDeductibleVATAmount: Decimal;        VATAmount: Decimal;        UnroundedVATAmount: Decimal;        VATAmountRounding: Decimal;        DeferralVATAmountRounding: Decimal;        PostingGLAccountNo: Code[20];        DeferralGLAccountNo: Code[20];        Sign: Decimal;        IsHandled: Boolean;    begin        IsHandled := false;#if not CLEAN29        if DeferralTemplate."Deferral Account" <> DeferralPostingBuffer."Deferral Account" then            VATAmountRounding := PositiveVATAmountRounding        else            VATAmountRounding := NegativeVATAmountRounding;        OnBeforeInsertDeferralNonDeductibleVATGLEntries(NonDeductibleVATPct, DeferralPostingBuffer, VATPostingSetup, GenJournalLine, DeferralTemplate, VATAmountRounding, PositiveNDVATAmountRounding, NegativeNDVATAmountRounding, IsHandled);        if DeferralTemplate."Deferral Account" <> DeferralPostingBuffer."Deferral Account" then            PositiveVATAmountRounding := VATAmountRounding        else            NegativeVATAmountRounding := VATAmountRounding;#endif        if not IsHandled then            OnBeforeInsertDeferralNonDeductibleVATGLEntries2(NonDeductibleVATPct, DeferralPostingBuffer, VATPostingSetup, GenJournalLine, DeferralTemplate, PositiveVATAmountRounding, NegativeVATAmountRounding, PositiveNDVATAmountRounding, NegativeNDVATAmountRounding, IsHandled);        if IsHandled then            exit;        if NonDeductibleVATPct = 0 then            exit;        if DeferralTemplate."Deferral Account" <> DeferralPostingBuffer."Deferral Account" then begin            DeferralGLAccountNo := DeferralPostingBuffer."G/L Account";            PostingGLAccountNo := DeferralPostingBuffer."Deferral Account";            VATAmountRounding := PositiveVATAmountRounding;            DeferralVATAmountRounding := PositiveNDVATAmountRounding;            Sign := 1;        end else begin            DeferralGLAccountNo := DeferralPostingBuffer."Deferral Account";            PostingGLAccountNo := DeferralPostingBuffer."G/L Account";            VATAmountRounding := NegativeVATAmountRounding;            DeferralVATAmountRounding := NegativeNDVATAmountRounding;            Sign := -1;        end;        UnroundedVATAmount := VATAmountRounding + DeferralPostingBuffer."Amount (LCY)" * VATPostingSetup."VAT %" / 100;        VATAmount := Round(UnroundedVATAmount, GLSetup."Amount Rounding Precision");        VATAmountRounding := UnroundedVATAmount - VATAmount;        NonDeductibleVATAmount :=          Sign * NonDeductibleVAT.GetNonDeductibleAmount(            VATAmount,            NonDeductibleVATPct,            GLSetup."Amount Rounding Precision", DeferralVATAmountRounding);        if Sign = 1 then begin            PositiveVATAmountRounding := VATAmountRounding;            PositiveNDVATAmountRounding := DeferralVATAmountRounding;        end else begin            NegativeVATAmountRounding := VATAmountRounding;            NegativeNDVATAmountRounding := DeferralVATAmountRounding;        end;        InitGLEntry(            GenJournalLine, GLEntry, DeferralGLAccountNo, NonDeductibleVATAmount, NonDeductibleVATAmount, true, true,            CalcAmountSrcCurr(GenJournalLine, NonDeductibleVATAmount));        GLEntry."Posting Date" := DeferralPostingBuffer."Posting Date";        GLEntry.Description := DeferralPostingBuffer.Description;        GLEntry.CopyFromDeferralPostBuffer(DeferralPostingBuffer);        InsertGLEntry(GenJournalLine, GLEntry, true);        InitGLEntry(            GenJournalLine, GLEntry, NonDeductibleVAT.GetNonDeductibleVATAccForDeferrals(DeferralDocType, PostingGLAccountNo, VATPostingSetup),            -NonDeductibleVATAmount, -NonDeductibleVATAmount, true, true,            CalcAmountSrcCurr(GenJournalLine, -NonDeductibleVATAmount));        GLEntry."Posting Date" := DeferralPostingBuffer."Posting Date";        GLEntry.Description := DeferralPostingBuffer.Description;        GLEntry.CopyFromDeferralPostBuffer(DeferralPostingBuffer);        InsertGLEntry(GenJournalLine, GLEntry, true);    end;    local procedure GetJournalsSourceCode()    begin        GetSourceCodeSetup();        JournalsSourceCodesList.Add(SourceCodeSetup."General Journal");        JournalsSourceCodesList.Add(SourceCodeSetup."Purchase Journal");        JournalsSourceCodesList.Add(SourceCodeSetup."Sales Journal");        OnAfterGetJournalsSourceCode(JournalsSourceCodesList);    end;    local procedure GetGeneralDeferralSourceCode(): Code[10]    begin        GetSourceCodeSetup();        SourceCodeSetup.TestField("General Deferral");        exit(SourceCodeSetup."General Deferral");    end;    local procedure GetSalesDeferralSourceCode(): Code[10]    begin        GetSourceCodeSetup();        SourceCodeSetup.TestField("Sales Deferral");        exit(SourceCodeSetup."Sales Deferral");    end;    local procedure GetPurchaseDeferralSourceCode(): Code[10]    begin        GetSourceCodeSetup();        SourceCodeSetup.TestField("Purchase Deferral");        exit(SourceCodeSetup."Purchase Deferral");    end;    procedure DeferralPosting(DeferralCode: Code[10]; SourceCode: Code[10]; AccountNo: Code[20]; var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean)    var        FeatureTelemetry: Codeunit "Feature Telemetry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeDeferralPosting(DeferralCode, SourceCode, AccountNo, GenJournalLine, Balancing, IsHandled);        if IsHandled then            exit;        if DeferralCode <> '' then begin            // Sales and purchasing could have negative amounts, so check for them first...            if (not JournalsSourceCodesList.Contains(SourceCode)) and             (GenJournalLine."Account Type" in [GenJournalLine."Account Type"::Customer, GenJournalLine."Account Type"::Vendor])            then                PostDeferralPostBuffer(GenJournalLine)            else                // Pure GL trx, only post deferrals if it is not a balancing entry                if not Balancing then                    PostDeferral(GenJournalLine, AccountNo);            FeatureTelemetry.LogUptake('0000KLB', 'Deferral', Enum::"Feature Uptake Status"::Used);            FeatureTelemetry.LogUsage('0000KLC', 'Deferral', 'Deferral Posted');        end;    end;    local procedure SetDeferralDescription(GenJournalLine: Record "Gen. Journal Line"; DeferralLine: Record "Deferral Line"; GLAccountNo: Code[20]): Text[100]    var        GLAccount: Record "G/L Account";        DeferralDescription: Text[100];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetDeferralDescription(GenJournalLine, DeferralLine, DeferralDescription, IsHandled, GLAccountNo);        if IsHandled then            exit(DeferralDescription);        DeferralDescription := GenJournalLine.Description;        GLAccount.Get(GLAccountNo);        CheckDescriptionForGL(GLAccount, DeferralDescription);        exit(DeferralDescription);    end;    local procedure SetDeferralDescriptionFromDeferralLine(DeferralLine: Record "Deferral Line"; GLAccountNo: Code[20]): Text[100]    var        GLAccount: Record "G/L Account";        DeferralDescription: Text[100];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetDeferralDescriptionFromDeferralLine(DeferralLine, DeferralDescription, IsHandled, GLAccountNo);        if IsHandled then            exit(DeferralDescription);        DeferralDescription := DeferralLine.Description;        GLAccount.Get(GLAccountNo);        CheckDescriptionForGL(GLAccount, DeferralDescription);        exit(DeferralDescription);    end;    local procedure SetDeferralDescriptionFromDeferralPostingBuffer(DeferralPostingBuffer: Record "Deferral Posting Buffer"; GLAccountNo: Code[20]): Text[100]    var        GLAccount: Record "G/L Account";        DeferralDescription: Text[100];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetDeferralDescriptionFromDeferralPostingBuffer(DeferralPostingBuffer, DeferralDescription, IsHandled, GLAccountNo);        if IsHandled then            exit(DeferralDescription);        DeferralDescription := DeferralPostingBuffer.Description;        GLAccount.Get(GLAccountNo);        CheckDescriptionForGL(GLAccount, DeferralDescription);        exit(DeferralDescription);    end;    local procedure SetPostingDimensions(var GenJnlLine: Record "Gen. Journal Line"; AccNo: Code[20])    var        DimMgt: Codeunit DimensionManagement;        DefaultDimSource: List of [Dictionary of [Integer, Code[20]]];        GenJournalAccountType: Enum "Gen. Journal Account Type";    begin        case GLSetup."App. Dimension Posting" of            GLSetup."App. Dimension Posting"::"No Dimensions":                begin                    GenJnlLine."Shortcut Dimension 1 Code" := '';                    GenJnlLine."Shortcut Dimension 2 Code" := '';                    GenJnlLine."Dimension Set ID" := 0;                end;            GLSetup."App. Dimension Posting"::"G/L Account Dimensions":                begin                    DimMgt.AddDimSource(                        DefaultDimSource, DimMgt.TypeToTableID1(GenJournalAccountType::"G/L Account".AsInteger()), AccNo, true);                    GenJnlLine.Validate("Dimension Set ID",                        DimMgt.GetRecDefaultDimID(                            GenJnlLine, 0, DefaultDimSource, GenJnlLine."Source Code",                            GenJnlLine."Shortcut Dimension 1 Code", GenJnlLine."Shortcut Dimension 2 Code", 0, 0));                end;        end;    end;    local procedure GetPostingAccountNo(VATPostingSetup: Record "VAT Posting Setup"; VATEntry: Record "VAT Entry"; UnrealizedVAT: Boolean): Code[20]    var        TaxJurisdiction: Record "Tax Jurisdiction";    begin        if VATPostingSetup."VAT Calculation Type" = VATPostingSetup."VAT Calculation Type"::"Sales Tax" then begin            VATEntry.TestField("Tax Jurisdiction Code");            TaxJurisdiction.Get(VATEntry."Tax Jurisdiction Code");            case VATEntry.Type of                VATEntry.Type::Sale:                    exit(TaxJurisdiction.GetSalesAccount(UnrealizedVAT));                VATEntry.Type::Purchase:                    begin                        if VATEntry."Use Tax" then                            exit(TaxJurisdiction.GetRevChargeAccount(UnrealizedVAT));                        exit(TaxJurisdiction.GetPurchAccount(UnrealizedVAT));                    end;            end;        end;        case VATEntry.Type of            VATEntry.Type::Sale:                exit(VATPostingSetup.GetSalesAccount(UnrealizedVAT));            VATEntry.Type::Purchase:                exit(VATPostingSetup.GetPurchAccount(UnrealizedVAT));        end;    end;    local procedure IsDebitAmount(DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; Unapply: Boolean): Boolean    var        VATPostingSetup: Record "VAT Posting Setup";        VATAmountCondition: Boolean;        EntryAmount: Decimal;    begin        VATAmountCondition :=            DtldCVLedgEntryBuf."Entry Type" in                [DtldCVLedgEntryBuf."Entry Type"::"Payment Discount (VAT Excl.)",                 DtldCVLedgEntryBuf."Entry Type"::"Payment Tolerance (VAT Excl.)",                 DtldCVLedgEntryBuf."Entry Type"::"Payment Discount Tolerance (VAT Excl.)"];        if VATAmountCondition then begin            VATPostingSetup.Get(DtldCVLedgEntryBuf."VAT Bus. Posting Group", DtldCVLedgEntryBuf."VAT Prod. Posting Group");            VATAmountCondition := VATPostingSetup."VAT Calculation Type" = VATPostingSetup."VAT Calculation Type"::"Full VAT";        end;        if VATAmountCondition then            EntryAmount := DtldCVLedgEntryBuf."VAT Amount (LCY)"        else            EntryAmount := DtldCVLedgEntryBuf."Amount (LCY)";        if Unapply then            exit(EntryAmount > 0);        exit(EntryAmount <= 0);    end;    local procedure GetVendorPostingGroup(GenJournalLine: Record "Gen. Journal Line"; var VendorPostingGroup: Record "Vendor Posting Group")    begin        VendorPostingGroup.Get(GenJournalLine."Posting Group");        OnAfterGetVendorPostingGroup(GenJournalLine, VendorPostingGroup);    end;    local procedure GetCustomerPostingGroup(GenJournalLine: Record "Gen. Journal Line"; var CustomerPostingGroup: Record "Customer Posting Group")    begin        CustomerPostingGroup.Get(GenJournalLine."Posting Group");        OnAfterGetCustomerPostingGroup(GenJournalLine, CustomerPostingGroup);    end;    local procedure GetCustomerReceivablesAccount(GenJournalLine: Record "Gen. Journal Line"; CustomerPostingGroup: Record "Customer Posting Group") ReceivablesAccount: Code[20]    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeGetCustomerReceivablesAccount(GenJournalLine, CustomerPostingGroup, ReceivablesAccount, IsHandled);        if not IsHandled then            ReceivablesAccount := CustomerPostingGroup.GetReceivablesAccount();        OnAfterGetCustomerReceivablesAccount(GenJournalLine, CustomerPostingGroup, ReceivablesAccount);    end;    local procedure GetVendorPayablesAccount(GenJournalLine: Record "Gen. Journal Line"; VendorPostingGroup: Record "Vendor Posting Group") PayablesAccount: Code[20]    begin        PayablesAccount := VendorPostingGroup.GetPayablesAccount();        OnAfterGetVendorPayablesAccount(GenJournalLine, VendorPostingGroup, PayablesAccount);    end;    local procedure GetEmployeePayablesAccount(GenJournalLine: Record "Gen. Journal Line"; EmployeePostingGroup: Record "Employee Posting Group") PayablesAccount: Code[20]    begin        PayablesAccount := EmployeePostingGroup.GetPayablesAccount();        OnAfterGetEmployeePayablesAccount(GenJournalLine, EmployeePostingGroup, PayablesAccount);    end;    local procedure IsNonDeferredRemainderEntry(DeferralPostingBuffer: Record "Deferral Posting Buffer"): Boolean    begin        exit(DeferralPostingBuffer."Partial Deferral" and (DeferralPostingBuffer.Amount = 0) and (DeferralPostingBuffer."Amount (LCY)" = 0));    end;    /// <summary>    /// Sets the new value for global variable FADimAlreadyChecked.    /// </summary>    /// <remarks>    /// If this value is not set (false) the dimensions are checked for restrictions when initializing new g/l entry    /// </remarks>    /// <param name="NewFADimAlreadyChecked">New value for global variable FADimAlreadyChecked</param>    procedure SetFADimAlreadyChecked(NewFADimAlreadyChecked: Boolean)    begin        FADimAlreadyChecked := NewFADimAlreadyChecked;    end;    /// <summary>    /// Sets entry no. of the global temporary/buffer table TempGLEntryBuf.    /// </summary>    /// <remarks>    /// TempGLEntryBuf is a global temporary/buffer table used to accumulate all the g/l entries that will be posted    /// </remarks>    /// <param name="NewTempGLEntryBufEntryNo">New entry no.</param>    procedure SetTempGLEntryBufEntryNo(NewTempGLEntryBufEntryNo: Integer)    begin        TempGLEntryBuf."Entry No." := NewTempGLEntryBufEntryNo;    end;    local procedure CalcSourceCurrVATBaseAmount(var GenJnlLine: Record "Gen. Journal Line"): Decimal    begin        if GenJnlLine."System-Created Entry" then            exit(GenJnlLine."Source Currency Amount");        if GenJnlLine."Source Currency Code" <> '' then begin            if GenJnlLine."Source Curr. VAT Base Amount" <> 0 then                exit(GenJnlLine."Source Curr. VAT Base Amount")            else                exit(GenJnlLine."Source Currency Amount");        end else            if (GenJnlLine."Source Currency amount" <> (GenJnlLine.Amount - GenJnlLine."VAT Amount")) and (GenJnlLine."Source Currency Amount" <> 0) then                exit(GenJnlLine."Source Currency amount")            else                exit(GenJnlLine.Amount - GenJnlLine."VAT Amount");    end;    local procedure GetVendorPayablesAccount2(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var GenJournalLine: Record "Gen. Journal Line"; VendPostingGr: Record "Vendor Posting Group"): Code[20]    begin        if MultiplePostingGroups then begin            DetailedCVLedgEntryBuffer.Reset();            DetailedCVLedgEntryBuffer.SetFilter("Entry Type", '%1|%2', DetailedCVLedgEntryBuffer."Entry Type"::"Realized Gain", DetailedCVLedgEntryBuffer."Entry Type"::"Realized Loss");            if DetailedCVLedgEntryBuffer.FindFirst() then                exit(GetVendDtldCVLedgEntryBufferAccNo(GenJournalLine, DetailedCVLedgEntryBuffer));            exit(GetVendorPayablesAccount(GenJournalLine, VendPostingGr));        end else            exit(GetVendorPayablesAccount(GenJournalLine, VendPostingGr));    end;    local procedure PostFAGLPostingBuffer(GenJnlLine: Record "Gen. Journal Line"; TempFAGLPostingBuffer: Record "FA G/L Posting Buffer"; var GLBalanceAmount: Decimal; var IsLastDepreciationEntry: Boolean)    var        GLEntry: Record "G/L Entry";        GLEntry2: Record "G/L Entry";        FALedgerEntry: Record "FA Ledger Entry";        FAAutomaticEntry: Codeunit "FA Automatic Entry";        NetDisposalNo: Integer;    begin        if (TempFAGLPostingBuffer."Entry No." = TempGLEntryBuf."Entry No.") and           (TempFAGLPostingBuffer."Account No." = TempGLEntryBuf."G/L Account No.") then begin            TempGLEntryBuf."FA Entry Type" := TempFAGLPostingBuffer."FA Entry Type";            TempGLEntryBuf."FA Entry No." := TempFAGLPostingBuffer."FA Entry No.";            TempGLEntryBuf.Modify();            exit;        end;        FALedgerEntry.SetLoadFields("FA Posting Type");        if not FALedgerEntry.Get(TempFAGLPostingBuffer."FA Entry No.") and (GLBalanceAmount = 0) then            exit;        if (FALedgerEntry."FA Posting Type" <> FALedgerEntry."FA Posting Type"::Depreciation) and (GLBalanceAmount = 0) then            exit;        if not IsLastDepreciationEntry and (GLBalanceAmount <> 0) then            exit;        InitGLEntry(            GenJnlLine, GLEntry, '', GenJnlLine."Amount (LCY)", GenJnlLine."Source Currency Amount", true, GenJnlLine."System-Created Entry",            CalcAmountSrcCurr(GenJnlLine, GenJnlLine."Amount (LCY)"));        GLEntry."Gen. Posting Type" := GenJnlLine."Gen. Posting Type";        GLEntry."Bal. Account Type" := GenJnlLine."Bal. Account Type";        GLEntry."Bal. Account No." := GenJnlLine."Bal. Account No.";        GLEntry2 := GLEntry;        if TempFAGLPostingBuffer."Original General Journal Line" then            InitGLEntry(                GenJnlLine, GLEntry, TempFAGLPostingBuffer."Account No.", TempFAGLPostingBuffer.Amount, GLEntry2."Additional-Currency Amount", true, true,                CalcAmountSrcCurr(GenJnlLine, TempFAGLPostingBuffer.Amount))        else begin            CheckNonAddCurrCodeOccurred('');            InitGLEntry(                GenJnlLine, GLEntry, TempFAGLPostingBuffer."Account No.", TempFAGLPostingBuffer.Amount, 0, false, true,                CalcAmountSrcCurr(GenJnlLine, TempFAGLPostingBuffer.Amount));        end;        FADimAlreadyChecked := false;        GLEntry.CopyPostingGroupsFromGLEntry(GLEntry);        GLEntry."FA Entry Type" := TempFAGLPostingBuffer."FA Entry Type";        GLEntry."FA Entry No." := TempFAGLPostingBuffer."FA Entry No.";        if TempFAGLPostingBuffer."Net Disposal" then            NetDisposalNo := NetDisposalNo + 1        else            NetDisposalNo := 0;        if TempFAGLPostingBuffer."Automatic Entry" and not TempFAGLPostingBuffer."Net Disposal" then            FAAutomaticEntry.AdjustGLEntry(GLEntry);        if NetDisposalNo > 1 then            GLEntry."VAT Amount" := 0;        InsertGLEntry(GenJnlLine, GLEntry, true);        GLBalanceAmount += TempFAGLPostingBuffer.Amount;        if GLBalanceAmount = 0 then            IsLastDepreciationEntry := false        else            IsLastDepreciationEntry := true;    end;    procedure IncreaseTaxEntryNo()    begin        NextTaxEntryNo := NextTaxEntryNo + 1;    end;    procedure SetApplyingCurrencyCode(NewApplyingCurrencyCode: Code[10])    begin        ApplyingCurrencyCode := NewApplyingCurrencyCode;    end;    local procedure IsApplicableCurrencyCodeNeeded(CurrencyCode: Code[10]): boolean    begin        if CurrencyCode <> '' then            exit(false);        if not IsCustApplnBetweenCurrencies() then            exit(false);        exit(true);    end;    local procedure IsCustApplnBetweenCurrencies(): Boolean    var        SalesReceivablesSetup: Record "Sales & Receivables Setup";    begin        SalesReceivablesSetup.SetLoadFields("Appln. between Currencies");        SalesReceivablesSetup.GetRecordOnce();        exit(SalesReceivablesSetup."Appln. between Currencies" = SalesReceivablesSetup."Appln. between Currencies"::All);    end;    local procedure GetPaymentDiscountVATExclNonDedVATAccountNo(VatEntry2: Record "VAT Entry"; NonDedVATAmount: Decimal): Code[20]    var        GeneralPostingSetup: Record "General Posting Setup";    begin        GeneralPostingSetup.SetLoadFields("Purch. Pmt. Disc. Debit Acc.", "Purch. Pmt. Disc. Credit Acc.");        GeneralPostingSetup.Get(VatEntry2."Gen. Bus. Posting Group", VatEntry2."Gen. Prod. Posting Group");        exit(GeneralPostingSetup.GetPurchPmtDiscountAccount(NonDedVATAmount > 0));    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeRunWithCheck(var GenJournalLine: Record "Gen. Journal Line"; var GenJournalLine2: Record "Gen. Journal Line"; var GLEntryNo: Integer; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeRunWithoutCheck(var GenJournalLine: Record "Gen. Journal Line"; var GenJournalLine2: Record "Gen. Journal Line"; var GLEntryNo: Integer; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCode(var GenJnlLine: Record "Gen. Journal Line"; CheckLine: Boolean; var IsPosted: Boolean; var GLReg: Record "G/L Register"; var GLEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckGLAccDimError(var GenJournalLine: Record "Gen. Journal Line"; GLAccNo: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckGLAccDirectPosting(var GenJournalLine: Record "Gen. Journal Line"; GLAcc: Record "G/L Account"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckDeferralPostDate(PostingDate: Date; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPurchExtDocNo(GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry"; CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var Handled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeStartPosting(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateGLEntryBalAcc(var GenJnlLine: Record "Gen. Journal Line"; var AccNo: Code[20]; Amount: Decimal; AmountAddCurr: Decimal; var BalAccType: Enum "Gen. Journal Account Type"; var BalAccNo: Code[20])    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterCreateGLEntryBalAcc(GenJnlLine: Record "Gen. Journal Line"; GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendPostApplyVendLedgEntryOnBeforeApplyVendLedgEntry(var VendorLedgerEntry: Record "Vendor Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateGLEntryVATOnBeforeInsertGLEntry(GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeStartOrContinuePosting(var GenJnlLine: Record "Gen. Journal Line"; LastDocType: Option " ",Payment,Invoice,"Credit Memo","Finance Charge Memo",Reminder; LastDocNo: Code[20]; LastDate: Date; var NextEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCodeOnAfterStartOrContinuePosting(var GenJournalLine: Record "Gen. Journal Line"; LastDocType: Enum "Gen. Journal Document Type"; LastDocNo: Code[20]; LastDate: Date; var NextEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitGLEntryVATCopyOnBeforeSummarizeVAT(GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateGLEntryOnBeforeInsertGLEntry(GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeContinuePosting(var GenJournalLine: Record "Gen. Journal Line"; var GLRegister: Record "G/L Register"; var NextEntryNo: Integer; var NextTransactionNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCustUnrealizedVAT(var GenJnlLine: Record "Gen. Journal Line"; var CustLedgEntry: Record "Cust. Ledger Entry"; SettledAmount: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostFixedAsset(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostGenJnlLine(var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostGLAcc(GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var GLEntryNo: Integer; var IsHandled: Boolean; var TempGLEntryBuf: Record "G/L Entry" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostVAT(var GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; VATPostingSetup: Record "VAT Posting Setup"; var IsHandled: Boolean; var AddCurrGLEntryVATAmt: Decimal; var NextConnectionNo: Integer; var TaxDetail: Record "Tax Detail")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostPmtDiscountVATByUnapply(var GenJournalLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostVend(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeFindAmtForAppln(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var AppliedAmount: Decimal; var AppliedAmountLCY: Decimal; var OldAppliedAmount: Decimal; var Handled: Boolean; var ApplnRoundingPrecision: Decimal; var VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeVendUnrealizedVAT(var GenJnlLine: Record "Gen. Journal Line"; var VendorLedgerEntry: Record "Vendor Ledger Entry"; SettledAmount: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterCustLedgEntryInsert(var CustLedgerEntry: Record "Cust. Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; var DtldLedgEntryInserted: Boolean; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertVATOnAfterCalcVATDifferenceLCY(GenJournalLine: Record "Gen. Journal Line"; VATEntry: Record "VAT Entry"; var VATDifferenceLCY: Decimal; var CurrExchRate: Record "Currency Exchange Rate")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertVATOnAfterSetVATAmounts(var GenJournalLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry"; var GLEntryAmount: Decimal; var GLEntryVATAmount: Decimal; var VATAmount: Decimal; var GLEntryBaseAmount: Decimal; var VATBase: Decimal; var SrcCurrGLEntryAmt: Decimal; var SrcCurrGLEntryVATAmt: Decimal; var SrcCurrVATAmount: Decimal; var SrcCurrGLEntryBaseAmt: Decimal; var SrcCurrVATBase: Decimal);    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterVendLedgEntryInsert(var VendorLedgerEntry: Record "Vendor Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; var DtldLedgEntryInserted: Boolean; PreviewMode: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterFindAmtForAppln(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var AppliedAmount: Decimal; var AppliedAmountLCY: Decimal; var OldAppliedAmount: Decimal; var ApplnRoundingPrecision: Decimal; var VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterFindJobLineSign(var GenJnlLine: Record "Gen. Journal Line"; var IsJobLine: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterInitGLEntry(var GLEntry: Record "G/L Entry"; GenJournalLine: Record "Gen. Journal Line"; Amount: Decimal; AddCurrAmount: Decimal; UseAddCurrAmount: Boolean; var CurrencyFactor: Decimal; var GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitGLRegister(var GLRegister: Record "G/L Register"; var GenJournalLine: Record "Gen. Journal Line"; NextTaxEntryNo: Integer; var NextEntryNo: Integer; var NextVATEntryNo: Integer; var NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitBankAccLedgEntry(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitCheckLedgEntry(var CheckLedgerEntry: Record "Check Ledger Entry"; BankAccountLedgerEntry: Record "Bank Account Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitCustLedgEntry(var CustLedgerEntry: Record "Cust. Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; var GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitVendLedgEntry(var VendorLedgerEntry: Record "Vendor Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; var GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitEmployeeLedgerEntry(var EmployeeLedgerEntry: Record "Employee Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertDtldCustLedgEntry(var DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; GenJournalLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; Offset: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertDtldVendLedgEntry(var DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; GenJournalLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; Offset: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertDtldCustLedgEntryUnapply(var CustomerPostingGroup: Record "Customer Posting Group"; var OldDetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var GenJnlLine: Record "Gen. Journal Line"; var NewDetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterInsertGlobalGLEntry(var GLEntry: Record "G/L Entry"; var TempGLEntryBuf: Record "G/L Entry"; var NextEntryNo: Integer; GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterInsertGLEntry(GLEntry: Record "G/L Entry"; GenJnlLine: Record "Gen. Journal Line"; TempGLEntryBuf: Record "G/L Entry" temporary; CalcAddCurrResiduals: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitVAT(var GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var VATPostingSetup: Record "VAT Posting Setup"; var AddCurrGLEntryVATAmt: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterInsertVAT(var GenJournalLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry"; var UnrealizedVAT: Boolean; var AddCurrencyCode: Code[10]; var VATPostingSetup: Record "VAT Posting Setup"; var GLEntryAmount: Decimal; var GLEntryVATAmount: Decimal; var GLEntryBaseAmount: Decimal; var SrcCurrCode: Code[10]; var SrcCurrGLEntryAmt: Decimal; var SrcCurrGLEntryVATAmt: Decimal; var SrcCurrGLEntryBaseAmt: Decimal; AddCurrGLEntryVATAmt: Decimal; var NextConnectionNo: Integer; var NextVATEntryNo: Integer; var NextTransactionNo: Integer; TempGLEntryBufEntryNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterInsertVATEntry(GenJnlLine: Record "Gen. Journal Line"; VATEntry: Record "VAT Entry"; GLEntryNo: Integer; var NextEntryNo: Integer; var TempGLEntryVATEntryLink: Record "G/L Entry - VAT Entry Link" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterIsNotPayment(DocumentType: Enum "Gen. Journal Document Type"; var Result: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostBankAcc(var GenJnlLine: Record "Gen. Journal Line"; Balancing: Boolean; var TempGLEntryBuf: Record "G/L Entry" temporary; var NextEntryNo: Integer; var NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterRunWithCheck(var GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterRunWithoutCheck(var GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostPmtDiscountVATByUnapply(var GenJournalLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterOldCustLedgEntryModify(var CustLedgEntry: Record "Cust. Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; var TempCustLedgerEntry: Record "Cust. Ledger Entry" temporary; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyCustLedgEntryOnBeforeCustUnrealizedVAT(CustLedgerEntry: Record "Cust. Ledger Entry"; var IsHandled: Boolean; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyCustLedgEntryOnBeforeUnrealizedVAT(CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var IsHandled: Boolean; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeApplyCustLedgEntry(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; Cust: Record Customer; var IsAmountToApplyCheckHandled: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterOldVendLedgEntryModify(var VendLedgEntry: Record "Vendor Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; var TempVendorLedgerEntry: Record "Vendor Ledger Entry" temporary; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; AppliedAmount: Decimal; var NextTaxEntryNo: Integer; var NextEntryNo: Integer; var NextCheckEntryNo: Integer; NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeApplyVendLedgEntry(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; Vend: Record Vendor; var IsAmountToApplyCheckHandled: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCustLedgEntryInsert(var CustLedgerEntry: Record "Cust. Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line"; GLRegister: Record "G/L Register"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var NextEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeVendLedgEntryInsert(var VendorLedgerEntry: Record "Vendor Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line"; GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDtldCustLedgEntry(var DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; GenJournalLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDtldCustLedgEntryProcedure(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDtldCustLedgEntryUnapply(var NewDtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; GenJournalLine: Record "Gen. Journal Line"; OldDtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDtldEmplLedgEntry(var DtldEmplLedgEntry: Record "Detailed Employee Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDtldEmplLedgEntryUnapply(var NewDtldEmplLedgEntry: Record "Detailed Employee Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; OldDtldEmplLedgEntry: Record "Detailed Employee Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDtldVendLedgEntry(var DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; GenJournalLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDtldVendLedgEntryProcedure(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDtldVendLedgEntryUnapply(var NewDtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; GenJournalLine: Record "Gen. Journal Line"; OldDtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertGLEntryBuffer(var TempGLEntryBuf: Record "G/L Entry" temporary; var GenJournalLine: Record "Gen. Journal Line"; var BalanceCheckAmount: Decimal; var BalanceCheckAmount2: Decimal; var BalanceCheckAddCurrAmount: Decimal; var BalanceCheckAddCurrAmount2: Decimal; var NextEntryNo: Integer; var TotalAmount: Decimal; var TotalAddCurrAmount: Decimal; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertGlobalGLEntry(var GlobalGLEntry: Record "G/L Entry"; GenJournalLine: Record "Gen. Journal Line"; GLRegister: Record "G/L Register"; FiscalYearStartDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertTempVATEntry(var TempVATEntry: Record "VAT Entry" temporary; GenJournalLine: Record "Gen. Journal Line"; VATEntry: Record "VAT Entry"; VATAmount: Decimal; VATBase: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitAmounts(var GenJnlLine: Record "Gen. Journal Line"; var Currency: Record Currency; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitBankAccLedgEntry(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitCheckEntry(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; var CheckLedgerEntry: Record "Check Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitCustLedgEntry(var CustLedgerEntry: Record "Cust. Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitEmployeeLedgEntry(var EmployeeLedgerEntry: Record "Employee Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitVendLedgEntry(var VendorLedgerEntry: Record "Vendor Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeInitGLEntry(var GenJournalLine: Record "Gen. Journal Line"; var GLAccNo: Code[20]; SystemCreatedEntry: Boolean; Amount: Decimal; AmountAddCurr: Decimal; FADimAlreadyChecked: Boolean; var IsHandled: Boolean; var GLEntry: Record "G/L Entry"; UseAmountAddCurr: Boolean; NextEntryNo: Integer; NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitVAT(var GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var VATPostingSetup: Record "VAT Posting Setup"; var IsHandled: Boolean; var LCYCurrency: Record Currency; var AddCurrencyCode: Code[10]; var AddCurrGLEntryVATAmt: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertGLEntryFromVATEntry(var GLEntry: Record "G/L Entry"; VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertVAT(var GenJournalLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry"; var UnrealizedVAT: Boolean; var AddCurrencyCode: Code[10]; var VATPostingSetup: Record "VAT Posting Setup"; var GLEntryAmount: Decimal; var GLEntryVATAmount: Decimal; var GLEntryBaseAmount: Decimal; var SrcCurrCode: Code[10]; var SrcCurrGLEntryAmt: Decimal; var SrcCurrGLEntryVATAmt: Decimal; var SrcCurrGLEntryBaseAmt: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeInsertVATForGLEntryFromBuffer(var GenJnlLine: Record "Gen. Journal Line"; var VATPostingSetup: Record "VAT Posting Setup"; VATPostingParameters: Record "VAT Posting Parameters"; var IsHandled: Boolean; var VATEntry: Record "VAT Entry"; TaxJurisdiction: Record "Tax Jurisdiction"; AddCurrencyCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertVATEntry(var VATEntry: Record "VAT Entry"; GenJournalLine: Record "Gen. Journal Line"; var NextVATEntryNo: Integer; var TempGLEntryVATEntryLink: Record "G/L Entry - VAT Entry Link" temporary; var TempGLEntryBuf: Record "G/L Entry" temporary; GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertPostUnrealVATEntry(var VATEntry: Record "VAT Entry"; GenJournalLine: Record "Gen. Journal Line"; var VATEntry2: Record "VAT Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeFinishPosting(var GenJournalLine: Record "Gen. Journal Line"; var TempGLEntryBuf: Record "G/L Entry" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterFinishPosting(var GlobalGLEntry: Record "G/L Entry"; var GLRegister: Record "G/L Register"; var IsTransactionConsistent: Boolean; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGLFinishPosting(GLEntry: Record "G/L Entry"; var GenJnlLine: Record "Gen. Journal Line"; var IsTransactionConsistent: Boolean; FirstTransactionNo: Integer; var GLRegister: Record "G/L Register"; var TempGLEntryBuf: Record "G/L Entry" temporary; var NextEntryNo: Integer; var NextTransactionNo: Integer; var NextVATEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnNextTransactionNoNeeded(GenJnlLine: Record "Gen. Journal Line"; LastDocType: Option " ",Payment,Invoice,"Credit Memo","Finance Charge Memo",Reminder; LastDocNo: Code[20]; LastDate: Date; CurrentBalance: Decimal; CurrentBalanceACY: Decimal; var NewTransaction: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostGLAcc(var GenJnlLine: Record "Gen. Journal Line"; var TempGLEntryBuf: Record "G/L Entry" temporary; var NextEntryNo: Integer; var NextTransactionNo: Integer; Balancing: Boolean; var GLEntry: Record "G/L Entry"; VATPostingSetup: Record "VAT Posting Setup"; var TempGLEntryVATEntryLink: Record "G/L Entry - VAT Entry Link" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtDiscOnAfterAssignPmtDisc(var PmtDisc: Decimal; var PmtDiscLCY: Decimal; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtDiscOnAfterCalcPmtDisc(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var PmtDisc: Decimal; var PmtDiscLCY: Decimal; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtToleranceOnAfterAssignPmtDisc(var PmtTol: Decimal; var PmtTolLCY: Decimal; var PmtTolAmtToBeApplied: Decimal; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var NextTransactionNo: Integer; var FirstNewVATEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtDiscIfAdjVATCopyFields(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostDeferral(var GenJournalLine: Record "Gen. Journal Line"; var TempGLEntryBuf: Record "G/L Entry" temporary; AccountNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostDeferralPostBuffer(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostDeferral(var GenJournalLine: Record "Gen. Journal Line"; var AccountNo: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostDeferralPostBuffer(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostJob(var GenJournalLine: Record "Gen. Journal Line"; GLEntry: Record "G/L Entry"; var IsJobLine: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCreateGLEntriesForTotalAmountsV19(var TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary; GenJournalLine: Record "Gen. Journal Line"; var GLAccNo: Code[20]; var IsHandled: Boolean; AdjAmountBuf: array[4] of Decimal; SavedEntryNo: Integer; LedgEntryInserted: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCreateGLEntriesForTotalAmountsUnapplyProcedure(GenJournalLine: Record "Gen. Journal Line"; var TempDimensionPostingBuffer: Record "Dimension Posting Buffer" temporary; GLAccountNo: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostDtldCVLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; Unapply: Boolean; AccNo: Code[20]; AdjAmount: array[4] of Decimal; var NextEntryNo: Integer; AddCurrencyCode: Code[10]; MultiplePostingGroups: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostDtldVendVATAdjustment(GenJournalLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostDtldCVLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var AccNo: Code[20]; var Unapply: Boolean; var AdjAmount: array[4] of Decimal; var IsHandled: Boolean; AddCurrencyCode: Code[10]; MultiplePostingGroups: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostDtldCVLedgEntryCreateGLEntryPmtDiscTol(var GenJournalLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var Unapply: Boolean; var AccNo: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostGenJnlLine(var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostCust(var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean; var TempGLEntryBuf: Record "G/L Entry" temporary; var NextEntryNo: Integer; var NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostVend(var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean; var TempGLEntryBuf: Record "G/L Entry" temporary; var NextEntryNo: Integer; var NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostVAT(GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; VATPostingSetup: Record "VAT Posting Setup"; var TaxDetail: Record "Tax Detail"; var NextConnectionNo: Integer; var AddCurrGLEntryVATAmt: Decimal; AddCurrencyCode: Code[10]; UseCurrFactorOnly: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcAmtLCYAdjustment(var CVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcAplication(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; var AppliedAmount: Decimal; var AppliedAmountLCY: Decimal; var OldAppliedAmount: Decimal; var PrevNewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var PrevOldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var AllApplied: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcApplicationOnBeforeCheckAppliedAmount(GenJournalLine: Record "Gen. Journal Line"; AppliedAmount: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcPmtTolerance(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; var PmtTolAmtToBeApplied: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcPmtDisc(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; var PmtTolAmtToBeApplied: Decimal; var IsHandled: Boolean; ApplnRoundingPrecision: Decimal; NextTransactionNo: Integer; FirstNewVATEntryNo: Integer; AddCurrencyCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcPmtDiscTolerance(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeFindNextOldCustLedgEntryToApply(var GenJournalLine: Record "Gen. Journal Line"; var TempOldCustLedgerEntry: Record "Cust. Ledger Entry" temporary; var NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var Completed: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeFindNextOldEmplLedgEntryToApply(var GenJournalLine: Record "Gen. Journal Line"; var TempOldEmployeeLedgerEntry: Record "Employee Ledger Entry" temporary; var NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var Completed: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeFindNextOldVendLedgEntryToApply(var GenJournalLine: Record "Gen. Journal Line"; var TempOldVendorLedgerEntry: Record "Vendor Ledger Entry" temporary; var NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var Completed: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetCurrencyExchRate(var GenJournalLine: Record "Gen. Journal Line"; var AddCurrencyCode: Code[10]; var UseCurrFactorOnly: Boolean; var CurrencyDate: Date; var CurrencyFactor: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetDtldCustLedgEntryAccNo(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var CustomerPostingGroup: Record "Customer Posting Group"; OriginalTransactionNo: Integer; Unapply: Boolean; var VATEntry: Record "VAT Entry"; var AccountNo: code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeGetDtldVendLedgEntryAccNo(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var VendorPostingGroup: Record "Vendor Posting Group"; OriginalTransactionNo: Integer; Unapply: Boolean; var VATEntry: Record "VAT Entry"; var AccountNo: code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetDtldEmplLedgEntryAccNo(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var EmployeePostingGroup: Record "Employee Posting Group"; OriginalTransactionNo: Integer; Unapply: Boolean; var AccountNo: code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetCustomerReceivablesAccount(GenJournalLine: Record "Gen. Journal Line"; CustomerPostingGroup: Record "Customer Posting Group"; var ReceivablesAccount: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcMinimalPossibleLiability(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var MinimalPossibleLiability: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcPaymentExceedsLiability(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var MinimalPossibleLiability: Decimal; var PaymentExceedsLiability: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcPmtDiscVATAmounts(var VATEntry: Record "VAT Entry"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtDiscIfAdjVATOnAfterCalcPmtDiscVATBases(var VATEntry: Record "VAT Entry"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var VATBase: Decimal; var VATBaseAddCurr: Decimal; var PmtDiscLCY2: Decimal; var PmtDiscAddCurr2: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcPmtDiscVATBases(VATEntry2: Record "VAT Entry"; var VATBase: Decimal; var VATBaseAddCurr: Decimal; var NonDeductibleVATBase: Decimal; var NonDeductibleVATBaseAddCurr: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtDiscIfAdjVATOnAfterCalcPmtDiscVATAmounts(var VATEntry: Record "VAT Entry"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var VATBase: Decimal; var VATBaseAddCurr: Decimal; var VATAmount: Decimal; var VATAmountAddCurr: Decimal; var PmtDiscLCY2: Decimal; var PmtDiscAddCurr2: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcPmtDiscIfAdjVAT(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; var PmtDiscLCY2: Decimal; var PmtDiscAddCurr2: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcToleratedPaymentExceedsLiability(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var MinimalPossibleLiability: Decimal; var ToleratedPaymentExceedsLiability: Boolean; var PmtTolAmtToBeApplied: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcPmtDiscount(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; var PmtTolAmtToBeApplied: Decimal; var PmtDisc: Decimal; var PmtDiscLCY: Decimal; var PmtDiscAddCurr: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcPmtDiscPossible(GenJnlLine: Record "Gen. Journal Line"; var CVLedgEntryBuf: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcPmtDiscTolerance(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; var PmtDiscTol: Decimal; var PmtDiscTolLCY: Decimal; var PmtDiscTolAddCurr: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcPmtDiscToleranceProc(DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var PmtDiscTol: Decimal; var PmtDiscTolLCY: Decimal; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcPmtTolerance(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var PmtTol: Decimal; var PmtTolLCY: Decimal; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitOldDtldCVLedgEntryBuf(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var PrevNewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var PrevOldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitNewDtldCVLedgEntryBuf(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var PrevNewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var PrevOldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcApplicationOnAfterFillOldCVLedgEntryBufOpen(var GenJnlLine: Record "Gen. Journal Line"; var OldCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcApplicationOnAfterCalcShouldSetClosedFields(CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var ShouldSetClosedFields: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterSettingIsTransactionConsistent(GenJournalLine: Record "Gen. Journal Line"; var IsTransactionConsistent: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcCurrencyApplnRounding(GenJnlLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf3: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcCurrencyRealizedGainLoss(var CVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary; var GenJnlLine: Record "Gen. Journal Line"; var AppliedAmount: Decimal; var AppliedAmountLCY: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcCurrencyUnrealizedGainLoss(var CVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary; var GenJnlLine: Record "Gen. Journal Line"; var AppliedAmount: Decimal; var RemainingAmountBeforeAppln: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcPmtDiscPossible(var GenJnlLine: Record "Gen. Journal Line"; var CVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var IsHandled: Boolean; RoundingPrecision: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCustPostApplyCustLedgEntry(var GenJnlLinePostApply: Record "Gen. Journal Line"; var CustLedgEntryPostApply: Record "Cust. Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustPostApplyCustLedgEntryOnBeforeRunCheck(var GenJournalLine: Record "Gen. Journal Line"; var CustLedgerEntryPostApply: Record "Cust. Ledger Entry"; var CustLedgerEntry: Record "Cust. Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeVendPostApplyVendLedgEntry(var GenJnlLinePostApply: Record "Gen. Journal Line"; var VendLedgEntryPostApply: Record "Vendor Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendPostApplyVendLedgEntryOnBeforeRunCheck(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostApply(GenJnlLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf2: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostApply(var GenJnlLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf2: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateGLReg(IsTransactionConsistent: Boolean; var IsGLRegInserted: Boolean; var GLReg: Record "G/L Register"; var IsHandled: Boolean; var GenJnlLine: Record "Gen. Journal Line"; GlobalGLEntry: Record "G/L Entry"; FirstNewVATEntryNo: Integer; NextTaxEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateTotalAmountsV19(var TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary; var DimSetID: Integer; var AmountToCollect: Decimal; var AmountACYToCollect: Decimal; var IsHandled: Boolean; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeInsertPmtDiscVATForGLEntry(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var GenJournalLine: Record "Gen. Journal Line"; VATEntry: Record "VAT Entry"; var VATPostingSetup: Record "VAT Posting Setup"; VATAmount: Decimal; VATAmountAddCurr: Decimal; NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var TempGLEntryVAT: Record "G/L Entry" temporary; var IsHandled: Boolean; NonDedVATAmount: Decimal; NonDedVATAmountAddCurr: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateGLEntryGainLossInsertGLEntry(var GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCreateGLEntriesForTotalAmountsUnapplyV19(DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var CustomerPostingGroup: Record "Customer Posting Group"; GenJournalLine: Record "Gen. Journal Line"; var TempIDimPostingBuffer: Record "Dimension Posting Buffer" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCreateGLEntriesForTotalAmountsUnapplyVendorV19(DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; var VendorPostingGroup: Record "Vendor Posting Group"; GenJournalLine: Record "Gen. Journal Line"; var TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitGLEntryVAT(var GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitGLEntryVAT(GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitGLEntryVATCopy(var GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var VATEntry: Record "VAT Entry"; var NextEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitGLEntryVATCopy(GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostUnrealVATEntry(GenJnlLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostUnapply(GenJnlLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry"; VATEntryType: Enum "General Posting Type"; BilltoPaytoNo: Code[20]; TransactionNo: Integer; UnapplyVATEntries: Boolean; var TempVATEntry: Record "VAT Entry" temporary; var IsHandled: Boolean; var NextVATEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostUnrealVATEntry(GenJnlLine: Record "Gen. Journal Line"; var VATEntry2: Record "VAT Entry"; VATAmount: Decimal; VATBase: Decimal; GLEntryNo: Integer; var NextEntryNo: Integer; var NextVATEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterHandleAddCurrResidualGLEntry(GenJournalLine: Record "Gen. Journal Line"; GLEntry2: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcCurrencyRealizedGainLoss(var CVLedgEntryBuf: Record "CV Ledger Entry Buffer"; AppliedAmount: Decimal; AppliedAmountLCY: Decimal; var RealizedGainLossLCY: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUnapplyVendLedgEntry(GenJournalLine2: Record "Gen. Journal Line"; DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUnapplyEmplLedgEntry(GenJournalLine2: Record "Gen. Journal Line"; DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateTotalAmounts(var TempDimPostingBuffer: Record "Dimension Posting Buffer"; DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSalesTaxCalculateCalculateTax(var GenJournalLine: Record "Gen. Journal Line"; GLEntry: Record "G/L Entry"; Currency: Record Currency)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSalesTaxCalculateInitSalesTaxLines(var GenJournalLine: Record "Gen. Journal Line"; GLEntry: Record "G/L Entry"; SalesTaxBaseAmount: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSalesTaxCalculateReverseCalculateTax(var GenJournalLine: Record "Gen. Journal Line"; GLEntry: Record "G/L Entry"; Currency: Record Currency)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateVATEntryTaxDetails(var VATEntry: Record "VAT Entry"; TaxDetail: Record "Tax Detail")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyCustLedgEntryOnAfterRecalculateAmounts(var TempOldCustLedgerEntry: Record "Cust. Ledger Entry" temporary; OldCustLedgerEntry: Record "Cust. Ledger Entry"; CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyCustLedgEntryOnAfterCalcShouldUpdateCalcInterestFromOldBuf(var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; Cust: Record Customer; var ShouldUpdateCalcInterest: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyCustLedgEntryOnBeforeCopyFromCVLedgEntryBuffer(var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; AppliedAmount: Decimal; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyCustLedgEntryOnBeforeCopyFromCustLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var OldCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var TempOldCustLedgEntry: Record "Cust. Ledger Entry"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyCustLedgEntryOnAfterCalcShouldUpdateCalcInterestFromNewBuf(var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; Cust: Record Customer; var ShouldUpdateCalcInterest: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyCustLedgEntryOnBeforePrepareTempCustLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var NextEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyCustLedgEntryOnAfterSetApplyingDate(ApplyingDate: Date);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyCustLedgerEntryOnBeforeSetCompleted(var GenJournalLine: Record "Gen. Journal Line"; var OldCustLedgEntry: Record "Cust. Ledger Entry"; var NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; AppliedAmount: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyVendLedgEntryOnAfterRecalculateAmounts(var TempOldVendorLedgerEntry: Record "Vendor Ledger Entry" temporary; OldVendorLedgerEntry: Record "Vendor Ledger Entry"; CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyVendLedgEntryOnBeforeUnrealizedVAT(var GenJournalLine: Record "Gen. Journal Line"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var VendorLedgerEntry: Record "Vendor Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnApplyVendLedgEntryOnBeforeTempOldVendLedgEntryDelete(var GenJournalLine: Record "Gen. Journal Line"; var TempVendorLedgerEntry: Record "Vendor Ledger Entry" temporary; AppliedAmount: Decimal; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyVendLedgEntryOnBeforeCopyFromVendLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var OldCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var TempOldVendLedgEntry: Record "Vendor Ledger Entry"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyVendLedgEntryOnBeforeOldVendLedgEntryModify(GenJnlLine: Record "Gen. Journal Line"; var OldVendLedgEntry: Record "Vendor Ledger Entry"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; AppliedAmount: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyVendLedgEntryOnBeforeVendUnrealizedVAT(VendLedgerEntry: Record "Vendor Ledger Entry"; var IsHandled: Boolean; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnApplyEmplLedgEntryOnBeforeOldEmplLedgEntryModify(GenJnlLine: Record "Gen. Journal Line"; var OldEmplLedgEntry: Record "Employee Ledger Entry"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; AppliedAmount: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCreateGLEntryForTotalAmountsForDimPostBuf(var GenJnlLine: Record "Gen. Journal Line"; TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary; var GLAccNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCustLedgEntryModify(var CustLedgerEntry: Record "Cust. Ledger Entry"; DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeVendLedgEntryModify(var VendorLedgerEntry: Record "Vendor Ledger Entry"; DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeEmplLedgEntryModify(var EmployeeLedgerEntry: Record "Employee Ledger Entry"; DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePrepareTempCustledgEntry(var GenJnlLine: Record "Gen. Journal Line"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; Customer: Record Customer; var ApplyingDate: Date; var Result: Boolean; var IsHandled: Boolean; var TempOldCustLedgEntry: Record "Cust. Ledger Entry" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePrepareTempVendLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var TempOldVendLedgEntry: Record "Vendor Ledger Entry" temporary; Vend: Record Vendor; var ApplyingDate: Date; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePrepareTempEmplLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var TempOldEmployeeLedgerEntry: Record "Employee Ledger Entry" temporary; Employee: Record Employee; var ApplyingDate: Date; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempVendLedgEntryOnBeforeTestPositive(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetDeferralDescription(GenJournalLine: Record "Gen. Journal Line"; DeferralLine: Record "Deferral Line"; var DeferralDescription: Text[100]; var IsHandled: Boolean; GLAccountNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetDeferralDescriptionFromDeferralLine(DeferralLine: Record "Deferral Line"; var DeferralDescription: Text[100]; var IsHandled: Boolean; GLAccountNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetDeferralDescriptionFromDeferralPostingBuffer(DeferralPostingBuffer: Record "Deferral Posting Buffer"; var DeferralDescription: Text[100]; var IsHandled: Boolean; GLAccountNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSummarizeVATFromInitGLEntryVAT(var GLEntry: Record "G/L Entry"; Amount: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtDiscIfAdjVATOnBeforeVATEntryFind(var GenJnlLine: Record "Gen. Journal Line"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var VATEntry: Record "VAT Entry"; var PmtDiscLCY2: Decimal; var PmtDiscAddCurr2: Decimal; var PmtDiscFactorLCY: Decimal; var PmtDiscFactorAddCurr: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtDiscAdjVATAmountsOnBeforeProcessVATEntry(var GenJnlLine: Record "Gen. Journal Line"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCalcPmtDiscIfAdjVATOnBeforeInsertSummarizedVATAfterLoop(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCalcPmtDiscIfAdjVATOnBeforeInsertSummarizedVATAdjForPaymentDiscount(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCalcPmtDiscIfAdjVATOnBeforeInsertPmtDiscVATForGLEntry(var VATEntry: Record "VAT Entry"; VATEntry2: Record "VAT Entry"; DtldCVLedgEntryBuf2: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateGLEntriesForTotalAmountsUnapplyOnBeforeCreateGLEntryV19(var GenJnlLine: Record "Gen. Journal Line"; var TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary; var GLAccNo: Code[20]);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateGLEntryForTotalAmountsOnBeforeInsertGLEntry(var GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var IsHandled: Boolean; var TempGLEntryVATEntryLink: Record "G/L Entry - VAT Entry Link" temporary);    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCodeOnAfterRunExhangeAccGLJournalLine(var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean; var NextEntryNo: Integer; var JobLine: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCodeOnBeforeFinishPosting(var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean; FirstEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnContinuePostingOnBeforeCalculateCurrentBalance(var GenJournalLine: Record "Gen. Journal Line"; var NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustPostApplyCustLedgEntryOnAfterCustLedgEntryTransferFields(var CustLedgerEntry: Record "Cust. Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustPostApplyCustLedgEntryOnBeforeCheckPostingGroup(var GenJournalLine: Record "Gen. Journal Line"; var Customer: Record Customer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustPostApplyCustLedgEntryOnBeforeFinishPosting(var GenJournalLine: Record "Gen. Journal Line"; CustLedgEntry: Record "Cust. Ledger Entry");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustPostApplyCustLedgEntryOnBeforePostDtldCustLedgEntries(var CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnFinishPostingOnBeforeResetFirstEntryNo(var GLEntry: Record "G/L Entry"; NextEntryNo: Integer; FirstEntryNo: Integer; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnHandleAddCurrResidualGLEntryOnBeforeInsertGLEntry(GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var TempGLEntryBuf: Record "G/L Entry"; NextEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnHandleDtldAdjustmentOnBeforeInitGLEntry(GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; TotalAmountLCY: Decimal; TotalAmountAddCurr: Decimal; GLAccNo: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitVATOnAfterSetGLEntryVATAmountForNormalVAT(GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitVATOnBeforeVATPostingSetupCheck(var GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var VATPostingSetup: Record "VAT Posting Setup"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitVATOnBeforeTestFullVATAccount(var GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var VATPostingSetup: Record "VAT Posting Setup"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertGLEntryOnBeforeCheckAmountRounding(var GLEntry: Record "G/L Entry"; var IsHandled: Boolean; var GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertGLEntryOnBeforeAssignTempGLEntryBuf(var GLEntry: Record "G/L Entry"; GenJournalLine: Record "Gen. Journal Line"; GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertPmtDiscVATForGLEntryOnAfterCopyFromGenJnlLine(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertTempVATEntryOnBeforeInsert(var VATEntry: Record "VAT Entry"; GenJournalLine: Record "Gen. Journal Line"; SourceVATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertVATEntriesFromTempOnBeforeVATEntryInsert(var VATEntry: Record "VAT Entry"; TempVATEntry: Record "VAT Entry" temporary; GLRegister: Record "G/L Register"; GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertVATOnAfterAssignVATEntryFields(GenJnlLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry"; CurrExchRate: Record "Currency Exchange Rate")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertVATOnBeforeCreateGLEntryForReverseChargeVATToPurchAcc(var GenJournalLine: Record "Gen. Journal Line"; var VATPostingSetup: Record "VAT Posting Setup"; UnrealizedVAT: Boolean; VATAmount: Decimal; VATAmountAddCurr: Decimal; UseAmountAddCurr: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertVATOnBeforeCreateGLEntryForReverseChargeVATToRevChargeAcc(var GenJournalLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; UnrealizedVAT: Boolean; var VATAmount: Decimal; var VATAmountAddCurr: Decimal; UseAmountAddCurr: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertVATOnBeforeVATForGLEntry(var GenJournalLine: Record "Gen. Journal Line"; var GLEntryVATAmountNotEmpty: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostApplyOnAfterRecalculateAmounts(var OldCVLedgerEntryBuffer2: Record "CV Ledger Entry Buffer"; var OldCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; GenJournalLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; AddCurrencyCode: Code[10]; NextTransactionNo: Integer; var NextVATEntryNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostBankAccOnAfterBankAccLedgEntryInsert(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line"; BankAccount: Record "Bank Account")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostBankAccOnBeforeBankAccLedgEntryInsert(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line"; BankAccount: Record "Bank Account"; var TempGLEntryBuf: Record "G/L Entry" temporary; var NextTransactionNo: Integer; GLRegister: Record "G/L Register"; Balancing: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostBankAccOnBeforeCheckLedgEntry2Modify(var CheckLedgEntry: Record "Check Ledger Entry"; var BankAccLedgEntry: Record "Bank Account Ledger Entry"; var CheckLedgerEntry2: Record "Check Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostBankAccOnAfterCheckLedgEntryInsert(var CheckLedgerEntry: Record "Check Ledger Entry"; var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line"; BankAccount: Record "Bank Account")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostBankAccOnBeforeCheckLedgEntryInsert(var CheckLedgerEntry: Record "Check Ledger Entry"; var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line"; BankAccount: Record "Bank Account"; TaxAmount: Decimal; TaxAmountLCY: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostBankAccOnBeforeInitBankAccLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; CurrencyFactor: Decimal; var NextEntryNo: Integer; var NextTransactionNo: Integer; var BankAccPostingGr: Record "Bank Account Posting Group"; var TaxAmount: Decimal; var TaxAmountLCY: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostBankAccOnAfterCheckLedgEntrySetFilters(var CheckLedgEntry: Record "Check Ledger Entry"; GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostBankAccOnBeforeModifyCheckLedgerEntry(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCustOnAfterCopyCVLedgEntryBuf(var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; GenJournalLine: Record "Gen. Journal Line"; Customer: Record Customer; CustLedgEntry: Record "Cust. Ledger Entry"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostCustOnAfterInitCustLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var CustLedgEntry: Record "Cust. Ledger Entry"; Cust: Record Customer; CustPostingGr: Record "Customer Posting Group")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostCustOnAfterCalcShouldCheckDocNo(var GenJournalLine: Record "Gen. Journal Line"; var ShouldCheckDocNo: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostCustOnBeforeInitCustLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var CustLedgEntry: Record "Cust. Ledger Entry"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var CustPostingGr: Record "Customer Posting Group")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostCustOnAfterTempDtldCVLedgEntryBufCopyFromGenJnlLine(var GenJournalLine: Record "Gen. Journal Line"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostCustOnBeforeTempDtldCVLedgEntryBufCopyFromGenJnlLine(var GenJournalLine: Record "Gen. Journal Line"; var CustLedgEntry: Record "Cust. Ledger Entry"; var Cust: Record Customer; GLReg: Record "G/L Register"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCustOnBeforeCopyFromCustLedgEntry(var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; GenJournalLine: Record "Gen. Journal Line"; Customer: Record Customer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustPostApplyCustLedgEntryOnBeforeCopyFromCustLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostVendOnAfterCopyCVLedgEntryBuf(var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostEmployeeOnAfterCopyCVLedgEntryBuf(var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostVendOnBeforeInitVendLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var VendLedgEntry: Record "Vendor Ledger Entry"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var VendPostingGr: Record "Vendor Posting Group")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostVendAfterTempDtldCVLedgEntryBufInit(var GenJnlLine: Record "Gen. Journal Line"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary; TaxAmount: Decimal; TaxAmountLCY: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostVendOnBeforeCopyCVLedgEntryBuf(var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; GenJournalLine: Record "Gen. Journal Line"; Vendor: Record Vendor)    begin    end;    [IntegrationEvent(false, false)]    procedure OnPostVendOnBeforeGetVendorPayablesAccount(GenJournalLine: Record "Gen. Journal Line"; VendorPostingGroup: Record "Vendor Posting Group"; var PayablesAccount: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDtldCVLedgEntryOnBeforeCreateGLEntryGainLoss(var GenJournalLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var Unapply: Boolean; var AccNo: Code[20]; var IsHandled: Boolean; var AdjAmount: array[4] of Decimal; AddCurrencyCode: Code[10]; MultiplePostingGroups: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldCVLedgEntryOnAfterCreateGLEntryPmtDiscTol(DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; TempGLEntryBuf: Record "G/L Entry" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldCVLedgEntryOnAfterCreateGLEntryPmtDiscTolVATExcl(DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; TempGLEntryBuf: Record "G/L Entry" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldCustLedgEntriesOnAfterCreateGLEntriesForTotalAmounts(var TempGLEntryBuf: Record "G/L Entry" temporary; var GlobalGLEntry: Record "G/L Entry"; NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDtldCustLedgEntriesOnBeforeCreateGLEntriesForTotalAmountsV19(var CustPostingGr: Record "Customer Posting Group"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; var TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary; AdjAmount: array[4] of Decimal; SaveEntryNo: Integer; GLAccNo: Code[20]; LedgerEntryInserted: Boolean; AddCurrencyCode: Code[10]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldEmplLedgEntriesOnBeforeUpdateTotalAmounts(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldEmplLedgEntriesOnAfterUpdateTotalAmounts(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldVendLedgEntriesOnAfterCreateGLEntriesForTotalAmounts(var TempGLEntryBuf: Record "G/L Entry" temporary; var GlobalGLEntry: Record "G/L Entry"; NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDtldEmplLedgEntriesOnAfterCreateGLEntriesForTotalAmounts(var TempGLEntryBuf: Record "G/L Entry" temporary; var GlobalGLEntry: Record "G/L Entry"; NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDtldVendLedgEntriesOnBeforeCreateGLEntriesForTotalAmounts(var VendPostingGr: Record "Vendor Posting Group"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJournalLine: Record "Gen. Journal Line"; var TempDimensionPostingBuffer: Record "Dimension Posting Buffer" temporary; AdjAmountBuf: array[4] of Decimal; SavedEntryNo: Integer; LedgEntryInserted: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldEmplLedgEntriesOnBeforeCreateGLEntriesForTotalAmounts(var EmplPostingGr: Record "Employee Posting Group"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJournalLine: Record "Gen. Journal Line"; var TempDimensionPostingBuffer: Record "Dimension Posting Buffer" temporary; AdjAmountBuf: array[4] of Decimal; SavedEntryNo: Integer; LedgEntryInserted: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldVendVATAdjustmentOnAfterFindVATEntry(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostGLAccOnBeforeInsertGLEntry(var GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var IsHandled: Boolean; Balancing: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostGLAccOnAfterInitGLEntry(var GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry");    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostGLAccOnBeforeDeferralPosting(var GenJournalLine: Record "Gen. Journal Line"; TaxAmount: Decimal; TaxAmountLCY: Decimal);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostFixedAssetOnAfterSaveGenJnlLineValues(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostFixedAssetOnBeforeAssignGLEntry(var GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var GLEntry2: Record "G/L Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostFixedAssetOnBeforeInsertGLEntry(var GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var IsHandled: Boolean; var TempFAGLPostBuf: Record "FA G/L Posting Buffer" temporary; GLEntry2: Record "G/L Entry"; NextEntyNo: Integer; var TempGLEntryVATEntryLink: Record "G/L Entry - VAT Entry Link" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostFixedAsset(var GenJournalLine: Record "Gen. Journal Line"; var TempGLEntryVATEntryLink: Record "G/L Entry - VAT Entry Link" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostFixedAssetOnBeforePostVAT(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostFixedAssetOnBeforeInitGLEntryFromTempFAGLPostBuf(var GenJournalLine: Record "Gen. Journal Line"; var TempFAGLPostBuf: Record "FA G/L Posting Buffer" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostFixedAssetOnBeforeGenJnlPostLine(GenJournalLine: Record "Gen. Journal Line"; GLEntry2: Record "G/L Entry"; NextTransactionNo: Integer; NextGLEntryNo: Integer; GLReg: Record "G/L Register"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDeferralOnBeforeInsertGLEntryForGLAccount(var GenJournalLine: Record "Gen. Journal Line"; DeferralLine: Record "Deferral Line"; var GLEntry: Record "G/L Entry"; GLRegisterNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDeferralOnBeforeInsertGLEntryForDeferralAccount(var GenJournalLine: Record "Gen. Journal Line"; DeferralLine: Record "Deferral Line"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDeferralOnBeforeInsertGLEntryDeferralLineForGLAccount(var GenJournalLine: Record "Gen. Journal Line"; DeferralLine: Record "Deferral Line"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDeferralOnBeforeInsertGLEntryDeferralLineForDeferralAccount(var GenJournalLine: Record "Gen. Journal Line"; DeferralLine: Record "Deferral Line"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDeferralOnAfterInsertGLEntry(var GenJournalLine: Record "Gen. Journal Line"; TempDeferralLine: Record "Deferral Line" temporary)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDeferralOnAfterTempDeferralLineLoopCompleted(var GenJournalLine: Record "Gen. Journal Line"; TempDeferralLine: Record "Deferral Line" temporary; DeferralTemplate: Record "Deferral Template"; DeferralHeader: Record "Deferral Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDeferralPostBufferOnBeforeInsertGLEntryForGLAccount(var GenJournalLine: Record "Gen. Journal Line"; DeferralPostingBuffer: Record "Deferral Posting Buffer"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDeferralPostBufferOnBeforeInsertGLEntryForDeferralAccount(var GenJournalLine: Record "Gen. Journal Line"; DeferralPostingBuffer: Record "Deferral Posting Buffer"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDeferralPostBufferOnAfterSetFilters(var DeferralPostBuffer: Record "Deferral Posting Buffer"; GenJournalLine: Record "Gen. Journal Line"; GLRegisterNo: Integer; NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDeferralPostBufferOnAfterInsertGLEntry(var GenJournalLine: Record "Gen. Journal Line"; var DeferralPostBuffer: Record "Deferral Posting Buffer")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDeferralPosBufferOnBeforeDeleteDeferralPostBuffer(var GenJournalLine: Record "Gen. Journal Line"; var DeferralPostBuffer: Record "Deferral Posting Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostEmployeeOnAfterPostDtldEmplLedgEntries(GenJournalLine: Record "Gen. Journal Line"; var EmployeeLedgerEntry: Record "Employee Ledger Entry"; var DtldLedgEntryInserted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUnapplyOnAfterVATEntrySetFilters(var VATEntry: Record "VAT Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUnapplyOnBeforeUnapplyVATEntry(var VATEntry: Record "VAT Entry"; var UnapplyVATEntry: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostUnapplyOnBeforeVATEntryInsert(var VATEntry: Record "VAT Entry"; GenJournalLine: Record "Gen. Journal Line"; OrigVATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempCustLedgEntryOnAfterSetFilters(var OldCustLedgerEntry: Record "Cust. Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var NextEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempCustLedgEntryOnBeforeExit(var GenJournalLine: Record "Gen. Journal Line"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var TempOldCustLedgEntry: Record "Cust. Ledger Entry" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempCustLedgEntryOnBeforeTestPositive(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempCustLedgEntryOnBeforeTempOldCustLedgEntryInsert(var CustLedgerEntry: Record "Cust. Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempEmplLedgEntryOnAppToIDOnBeforeTempOldEmplLedgEntryInsert(var EmplLedgEntry: Record "Employee Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempEmplLedgEntryOnAppDocNoOnBeforeTempOldEmplLedgEntryInsert(var EmplLedgEntry: Record "Employee Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempEmplLedgEntryOnAfterSetFiltersByAppliesToId(var OldEmplLedgEntry: Record "Employee Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; Employee: Record Employee)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempVendLedgEntryOnAfterSetFilters(var OldVendorLedgerEntry: Record "Vendor Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempVendLedgEntryOnAfterSetFiltersBlankAppliesToDocNo(var OldVendorLedgerEntry: Record "Vendor Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; Vendor: Record Vendor)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempVendLedgEntryOnBeforeExit(var GenJournalLine: Record "Gen. Journal Line"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var TempOldVendLedgEntry: Record "Vendor Ledger Entry" temporary)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempVendLedgEntryOnBeforeTempOldVendLedgEntryInsert(var VendorLedgerEntry: Record "Vendor Ledger Entry"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyCustLedgEntryOnAfterCreateGLEntriesForTotalAmounts(var GenJournalLine: Record "Gen. Journal Line"; DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; GLReg: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyCustLedgEntryOnAfterDtldCustLedgEntrySetFilters(var DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry"; DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyCustLedgEntryOnBeforeCheckPostingGroup(var GenJournalLine: Record "Gen. Journal Line"; Customer: Record Customer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnUnapplyCustLedgEntryOnAfterPostUnapply(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyCustLedgEntryOnBeforePostUnapply(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnUnapplyCustLedgEntryOnAfterUpdateTotals(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyCustLedgEntryOnBeforeUpdateCustLedgEntry(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var DetailedCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnUnapplyVendLedgEntryOnAfterCreateGLEntriesForTotalAmounts(var GenJournalLine: Record "Gen. Journal Line"; DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; GLReg: Record "G/L Register"; GenJournalLineToPost: Record "Gen. Journal Line"; var NextTaxEntryNo: Integer; var NextEntryNo: Integer; var NextCheckEntryNo: Integer; NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyVendLedgEntryOnAfterFilterSourceEntries(var DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; var DetailedVendorLedgEntry2: Record "Detailed Vendor Ledg. Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyVendLedgEntryOnBeforeCheckPostingGroup(var GenJournalLine: Record "Gen. Journal Line"; Vendor: Record Vendor)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnUnapplyVendLedgEntryOnAfterPostUnapply(var GenJournalLine: Record "Gen. Journal Line"; var DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; var DetailedVendorLedgEntry2: Record "Detailed Vendor Ledg. Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyVendLedgEntryOnBeforePostUnapply(var DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; var DetailedVendorLedgEntry2: Record "Detailed Vendor Ledg. Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyVendLedgEntryOnBeforeUpdateVendLedgEntry(var DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; var DetailedCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyEmplLedgEntryOnBeforeUpdateTotalAmounts(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustUnrealizedVATOnAfterVATPartCalculation(GenJournalLine: Record "Gen. Journal Line"; var CustLedgerEntry: Record "Cust. Ledger Entry"; PaidAmount: Decimal; TotalUnrealVATAmountFirst: Decimal; TotalUnrealVATAmountLast: Decimal; SettledAmount: Decimal; VATEntry2: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustUnrealizedVATOnAfterCalcPaidAmount(GenJnlLine: Record "Gen. Journal Line"; var CustLedgEntry2: Record "Cust. Ledger Entry"; SettledAmount: Decimal; var PaidAmount: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendUnrealizedVATOnAfterCalcPaidAmount(GenJnlLine: Record "Gen. Journal Line"; var VendLedgEntry2: Record "Vendor Ledger Entry"; SettledAmount: Decimal; var PaidAmount: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustUnrealizedVATOnBeforeInitGLEntryVAT(var GenJournalLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry"; var VATAmount: Decimal; var VATBase: Decimal; var VATAmountAddCurr: Decimal; var VATBaseAddCurr: Decimal; var IsHandled: Boolean; var SalesVATUnrealAccount: Code[20]; CustLedgerEntry: Record "Cust. Ledger Entry"; SettledAmount: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustUnrealizedVATOnAfterSetSalesVATAccounts(var VATEntry: Record "VAT Entry"; var VATPostingSetup: Record "VAT Posting Setup"; var SalesVATAccount: Code[20]; var SalesVATUnrealAccount: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendPostApplyVendLedgEntryOnAfterVendLedgEntryTransferFields(var VendorLedgerEntry: Record "Vendor Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendPostApplyVendLedgEntryOnBeforeCheckPostingGroup(var GenJournalLine: Record "Gen. Journal Line"; Vendor: Record Vendor)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetVendorPayablesAccount(GenJournalLine: Record "Gen. Journal Line"; VendorPostingGroup: Record "Vendor Posting Group"; var PayablesAccount: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeGetEmployeePayablesAccount(GenJournalLine: Record "Gen. Journal Line"; EmployeePostingGroup: Record "Employee Posting Group"; var PayablesAccount: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendPostApplyVendLedgEntryOnBeforeFinishPosting(var GenJournalLine: Record "Gen. Journal Line"; VendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendPostApplyVendLedgEntryOnBeforePostDtldVendLedgEntries(var VendorLedgEntry: Record "Vendor Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendPostApplyVendLedgEntryOnBeforeCheckPostUnrealizedVAT(var GenJournalLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var DtldLedgEntryInserted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendUnrealizedVATOnAfterVATPartCalculation(GenJournalLine: Record "Gen. Journal Line"; var VendorLedgerEntry: Record "Vendor Ledger Entry"; PaidAmount: Decimal; TotalUnrealVATAmountFirst: Decimal; TotalUnrealVATAmountLast: Decimal; SettledAmount: Decimal; VATEntry2: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendUnrealizedVATOnBeforeInitGLEntryVAT(var GenJournalLine: Record "Gen. Journal Line"; var VATEntry: Record "VAT Entry"; var VATAmount: Decimal; var VATBase: Decimal; var VATAmountAddCurr: Decimal; var VATBaseAddCurr: Decimal; VendorLedgerEntry: Record "Vendor Ledger Entry"; SettledAmount: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnMoveGenJournalLine(var GenJournalLine: Record "Gen. Journal Line"; ToRecordID: RecordID)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitLastDocDate(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateCustLedgEntry(DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var TempGLEntryBuf: Record "G/L Entry" temporary; var GlobalGLEntry: Record "G/L Entry"; NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateVendLedgEntry(DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; var TempGLEntryBuf: Record "G/L Entry" temporary; var GlobalGLEntry: Record "G/L Entry"; NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnApplyCustLedgEntryOnBeforeTempOldCustLedgEntryDelete(var TempOldCustLedgEntry: Record "Cust. Ledger Entry" temporary; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var GenJnlLine: Record "Gen. Journal Line"; var Cust: Record Customer; NextEntryNo: Integer; GLReg: Record "G/L Register"; AppliedAmount: Decimal; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostUnrealVATByUnapply(GenJnlLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; VATEntry: Record "VAT Entry"; NewVATEntry: Record "VAT Entry");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostUnrealVATByUnapply(GenJnlLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; VATEntry: Record "VAT Entry"; NewVATEntry: Record "VAT Entry");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtDiscPossibleOnBeforeOriginalPmtDiscPossible(GenJnlLine: Record "Gen. Journal Line"; var CVLedgEntryBuf: Record "CV Ledger Entry Buffer"; AmountRoundingPrecision: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempCustLedgEntryOnAfterSetFiltersByAppliesToId(var OldCustLedgerEntry: Record "Cust. Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; Customer: Record Customer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterApplyCustLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCustLedgEntry: Record "Cust. Ledger Entry"; NewRemainingAmtBeforeAppln: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterApplyVendLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldVendLedgEntry: Record "Vendor Ledger Entry"; NewRemainingAmtBeforeAppln: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterApplyEmplLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldEmployeeLedgerEntry: Record "Employee Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetCustomerReceivablesAccount(GenJournalLine: Record "Gen. Journal Line"; CustomerPostingGroup: Record "Customer Posting Group"; var ReceivablesAccount: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetCustomerPostingGroup(GenJournalLine: Record "Gen. Journal Line"; var CustomerPostingGroup: Record "Customer Posting Group")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetVendorPostingGroup(GenJournalLine: Record "Gen. Journal Line"; var VendorPostingGroup: Record "Vendor Posting Group")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetVendorPayablesAccount(GenJournalLine: Record "Gen. Journal Line"; VendorPostingGroup: Record "Vendor Posting Group"; var PayablesAccount: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetEmployeePayablesAccount(GenJournalLine: Record "Gen. Journal Line"; EmployeePostingGroup: Record "Employee Posting Group"; var PayablesAccount: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetVendUnrealizedVATAccounts(VATEntry: Record "VAT Entry"; VATPostingSetup: Record "VAT Posting Setup"; var PurchVATAccount: Code[20]; var PurchVATUnrealAccount: Code[20]; var PurchReverseAccount: Code[20]; var PurchReverseUnrealAccount: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUnapplyOnAfterVATEntryInsert(var VATEntry: Record "VAT Entry"; GenJournalLine: Record "Gen. Journal Line"; OrigVATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUpdateCalcInterestOnAfterCustLedgEntrySetFilters(var CustLedgEntry: Record "Cust. Ledger Entry"; CVLedgEntryBuf: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendUnrealizedVATOnAfterCalcTotalUnrealVATAmount(var VATEntry2: Record "VAT Entry"; var TotalUnrealVATAmountFirst: Decimal; var TotalUnrealVATAmountLast: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCustUnrealizedVATOnBeforePostUnrealVATEntry(var GenJnlLine: Record "Gen. Journal Line"; var VATEntry2: Record "VAT Entry"; var VATAmount: Decimal; var VATBase: Decimal; var VATAmountAddCurr: Decimal; var VATBaseAddCurr: Decimal; var GLEntryNo: Integer; VATPart: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnVendUnrealizedVATOnBeforePostUnrealVATEntry(var GenJnlLine: Record "Gen. Journal Line"; var VATEntry2: Record "VAT Entry"; var VATAmount: Decimal; var VATBase: Decimal; var VATAmountAddCurr: Decimal; var VATBaseAddCurr: Decimal; var GLEntryNo: Integer; VATPart: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostUnrealVATByUnapplyOnBeforeVATEntryModify(GenJnlLine: Record "Gen. Journal Line"; VATPostingSetup: Record "VAT Posting Setup"; VATEntry: Record "VAT Entry"; NewVATEntry: Record "VAT Entry"; var VATEntry2: Record "VAT Entry"; var GLEntryNoFromVAT: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcPmtTolerancePossible(GenJnlLine: Record "Gen. Journal Line"; PmtDiscountDate: Date; var PmtDiscToleranceDate: Date; var MaxPaymentTolerance: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeDeferralPosting(DeferralCode: Code[10]; SourceCode: Code[10]; var AccountNo: Code[20]; var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckSalesExtDocNo(var GenJnlLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckPurchExtDocNoProcedure(var GenJnlLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostICPartner(var GenJnlLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterStartPosting(GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCustOnAfterAssignCurrencyFactors(var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostVendOnAfterAssignCurrencyFactors(var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostEmployeeOnAfterAssignCurrencyFactors(var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnInitAmountsOnAddCurrencyPostingNone(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostVendOnAfterInitVendLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var VendLedgEntry: Record "Vendor Ledger Entry"; Vendor: Record Vendor; var TaxAmount: Decimal; var TaxAmountLCY: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnInsertSummarizedVATOnAfterInsertGLEntry(var GenJnlLine: Record "Gen. Journal Line"; var TempGLEntryVAT: Record "G/L Entry" temporary; NextEntryNo: Integer)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostBankAccOnBeforeCreateGLEntryBalAcc(var GenJnlLine: Record "Gen. Journal Line"; BankAccPostingGr: Record "Bank Account Posting Group"; BankAccount: Record "Bank Account"; NextEntryNo: Integer; var IsHandled: Boolean; TaxAmount: Decimal; TaxAmountLCY: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostFixedAssetOnAfterSetGenJnlLineShortcutDimCodes(var GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostICPartnerOnBeforeCreateGLEntryBalAcc(var GenJnlLine: Record "Gen. Journal Line"; NextEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertGlEntry(var GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterCreateGLEntry(var GenJnlLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; NextEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcApplication(var GenJnlLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCustPostApplyCustLedgEntryOnAfterApplyCustLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCustPostApplyCustLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var GLReg: Record "G/L Register"; CustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSetDtldCustLedgEntryNoOffset(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var DtldCustLedgEntryNoOffset: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldCustLedgEntriesOnBeforeUpdateTotalAmounts(var GenJnlLine: Record "Gen. Journal Line"; DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var IsHandled: Boolean; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDtldCustLedgEntriesOnBeforePostDtldCustLedgEntry(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; AddCurrencyCode: Code[10]; var GenJnlLine: Record "Gen. Journal Line"; CustPostingGr: Record "Customer Posting Group"; AdjAmount: array[4] of Decimal; var IsHandled: Boolean; var NextEntryNo: Integer; DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; LedgEntryInserted: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnVendPostApplyVendLedgEntryOnAfterApplyVendLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendPostApplyVendLedgEntryOnBeforeCopyFromVendLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var VendLedgEntry: Record "Vendor Ledger Entry");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterVendPostApplyVendLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; GLReg: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldVendLedgEntriesOnBeforeUpdateTotalAmounts(var GenJnlLine: Record "Gen. Journal Line"; DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; var IsHandled: Boolean; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDtldVendLedgEntriesOnBeforePostDtldVendLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; VendPostingGr: Record "Vendor Posting Group"; AdjAmount: array[4] of Decimal; var IsHandled: Boolean; LedgEntryInserted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldVendLedgEntriesOnAfterPostDtldVendLedgEntry(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; LedgEntryInserted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnOnUnapplyCustLedgEntryOnBeforeSecondLook(var DtldCustLedgEntry2: Record "Detailed Cust. Ledg. Entry"; NextDtldLedgEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyCustLedgEntryOnAfterFillDtldCVLedgEntryBuf(var GenJnlLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnOnUnapplyCustLedgEntryOnBeforeUpdateTotalAmounts(var IsHandled: Boolean; var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSetDtldVendLedgEntryNoOffset(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var DtldVendLedgEntryNoOffset: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyVendLedgEntryOnBeforeSecondLook(var DtldVendLedgEntry2: Record "Detailed Vendor Ledg. Entry"; NextDtldLedgEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyVendLedgEntryOnAfterFillDtldCVLedgEntryBuf(var GenJnlLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyVendLedgEntryOnBeforeUpdateTotalAmounts(var IsHandled: Boolean; var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnProcessTempVATEntryCustOnAfterProcessTempVATEntry(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var TempVATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGLCalcAddCurrencyPostingNone(var GenJnlLine: Record "Gen. Journal Line"; Amount: Decimal; AddCurrency: Record Currency; var Result: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetCurrencyExchRateOnAfterSetNewCurrencyDate(var GenJnlLine: Record "Gen. Journal Line"; var NewCurrencyDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetCurrencyExchRate(var GenJnlLine: Record "Gen. Journal Line"; NewCurrencyDate: Date; CurrencyDate: Date; UseCurrFactorOnly: Boolean; var CurrencyFactor: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDtldAdjustmentOnBeforeCreateGLEntryBalAcc(var GenJnlLine: Record "Gen. Journal Line"; GLAcc: Code[20]; AdjAmount: array[4] of Decimal; ArrayIndex: Integer; var IsHandled: Boolean; NextEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitVATOnVATCalculationTypeNormal(var GenJnlLine: Record "Gen. Journal Line"; var IsHandled: Boolean; var GLEntry: Record "G/L Entry"; var VATPostingSetup: Record "VAT Posting Setup")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostVendOnBeforePostDtldVendLedgEntries(var VendorLedgerEntry: Record "Vendor Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var NextEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnContinuePostingOnIncreaseNextTransactionNo(var GenJnlLine: Record "Gen. Journal Line"; var NextTransactionNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostEmployeeOnBeforeEmployeeLedgerEntryInsert(var GenJnlLine: Record "Gen. Journal Line"; var EmployeeLedgerEntry: Record "Employee Ledger Entry"; GLRegister: Record "G/L Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCustOnBeforeResetCustLedgerEntryAppliesToFields(var CustLedgEntry: Record "Cust. Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostVendOnAfterAssignPayablesAccount(GenJnlLine: Record "Gen. Journal Line"; VendorPostingGroup: Record "Vendor Posting Group"; var PayablesAccount: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCustOnAfterAssignReceivablesAccount(GenJnlLine: Record "Gen. Journal Line"; CustomerPostingGroup: Record "Customer Posting Group"; var ReceivablesAccount: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckDimValueForDisposal(var GenJnlLine: Record "Gen. Journal Line"; AccountNo: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSetUnrealizedVAT(var GenJnlLine: Record "Gen. Journal Line"; var VATPostingSetup: Record "VAT Posting Setup"; var UnrealizedVAT: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertPmtDiscVATForGLEntry(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldCustVATAdjustmentOnAfterFindVATEntry(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterPostDtldCustVATAdjustment(GenJnlLine: Record "Gen. Journal Line"; DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeShowInconsistentEntries(TempGLEntryPrevie: Record "G/L Entry" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitGLEntryOnBeforeCheckGLAccDimError(var GenJnlLine: Record "Gen. Journal Line"; var GLAcc: Record "G/L Account")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDeferralPostBufferOnAfterSetPostDate(var DeferralPostBuffer: Record "Deferral Posting Buffer"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeEmplPostApplyEmplLedgEntry(var GenJnlLinePostApply: Record "Gen. Journal Line"; var EmplLedgEntryPostApply: Record "Employee Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUnapplyVendLedgEntry(GenJnlLine2: Record "Gen. Journal Line"; DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUnapplyCustLedgEntry(GenJnlLine2: Record "Gen. Journal Line"; DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckGenJnlLine(GenJnlLine: Record "Gen. Journal Line"; CheckLine: Boolean; var OverrideDimErr: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUnapplyEmplLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckCustMultiplePostingGroups(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var IsMultiplePostingGroups: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckVendMultiplePostingGroups(var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var IsMultiplePostingGroups: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempEmplLedgEntryOnBeforeUpdateRemainingAmount(var TempOldEmployeeLedgerEntry: Record "Employee Ledger Entry"; var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDtldVendVATAdjustmentOnBeforeCreateGLEntryReverseChargeVATInPostDtldVendVATAdjustment(DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; VATEntry: Record "VAT Entry"; GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDtldVendVATAdjustmentOnBeforeCreateGLEntrySalesTaxInPostDtldVendVATAdjustment(DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; VATEntry: Record "VAT Entry"; GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUnrealVATEntryOnBeforeInsertLinkSelf(var TempGLEntryVATEntryLink: Record "G/L Entry - VAT Entry Link" temporary; var VATEntry: record "VAT Entry"; var GLEntryNo: Integer; var NextVATEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostBankAcc(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateGLEntryVAT(var GenJournalLine: Record "Gen. Journal Line"; DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateGLEntryVATCollectAdj(var GenJournalLine: Record "Gen. Journal Line"; DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempCustLedgEntryOnBeforeCheckAgainstApplnCurrencyWithAppliesToDocNo(GenJournalLine: Record "Gen. Journal Line"; NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; OldCustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempCustLedgEntryOnBeforeCheckAgainstApplnCurrency(GenJournalLine: Record "Gen. Journal Line"; NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; OldCustLedgerEntry: Record "Cust. Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempVendLedgEntryOnBeforeCheckAgainstApplnCurrencyWithAppliesToDocNo(GenJournalLine: Record "Gen. Journal Line"; NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; OldVendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPrepareTempVendLedgEntryOnBeforeCheckAgainstApplnCurrency(GenJournalLine: Record "Gen. Journal Line"; NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; OldVendorLedgerEntry: Record "Vendor Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitGLEntryVATOnVendUnrealizedVAT(var VATEntry: Record "VAT Entry"; var GenJournalLine: Record "Gen. Journal Line"; var NextEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitGLEntryVATOnVendUnrealizedVATForRevChargeVAT(var VATEntry: Record "VAT Entry"; var GenJournalLine: Record "Gen. Journal Line"; var NextEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitGLEntryVATOnBeforeSummarizeVAT(GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendUnrealizedVATOnAfterSetFilterForVATEntry2(var VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustUnrealizedVATOnAfterSetFilterForVATEntry2(var VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostDtldVendVATAdjustmentOnBeforeCreateGLEntryForNormalOrFullVAT(DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; VATEntry: Record "VAT Entry"; GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostDtldVendLedgEntryUnapply(GenJournalLine: Record "Gen. Journal Line"; DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; VendPostingGr: Record "Vendor Posting Group"; OriginalTransactionNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyVendLedgEntryOnBeforeUpdateDetailedVendLedgEntry2(var DetailedVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; var DetailedCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertDtldVendLedgEntryUnapply(var OldDetailedVendLedgEntry: Record "Detailed Vendor Ledg. Entry"; var GenJnlLine: Record "Gen. Journal Line"; var NewDetailedVendLedgEntry: Record "Detailed Vendor Ledg. Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostDtldCustLedgEntryUnapply(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; CustPostingGroup: Record "Customer Posting Group"; OriginalTransactionNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyCustLedgEntryOnBeforeUpdateDetailedCustLedgEntry(var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var DetailedCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterCreateNormalVATGLEntries(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCheckGenJnlLineOnBeforeRunCheck(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnPostGLAccOnBeforePostJob(var GenJournalLine: Record "Gen. Journal Line"; var GLEntry: Record "G/L Entry"; var IsHandled: Boolean; Balancing: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCreateGLEntriesForTotalAmountsUnapplyOnBeforeUpdateGenJnlLineDim(var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterGetJournalsSourceCode(var JournalsSourceCodesList: List of [Code[10]])    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCreateGLEntriesForTotalAmountsOnBeforeUpdateGenJnlLineDim(var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnStartPostingOnBeforeSetNextVatEntryNo(var VatEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnStartPostingOnAfterSetNextVatEntryNo(var VatEntry: Record "VAT Entry"; var NextVATEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertGLEntryOnBeforeUpdateCheckAmounts(GeneralLedgerSetup: Record "General Ledger Setup"; var GLEntry: Record "G/L Entry"; var BalanceCheckAmount: Decimal; var BalanceCheckAmount2: Decimal; var BalanceCheckAddCurrAmount: Decimal; var BalanceCheckAddCurrAmount2: Decimal);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDeferralPostBufferOnAfterFindDeferalPostingBuffer(var GenJournalLine: Record "Gen. Journal Line"; var DeferralPostingBuffer: Record "Deferral Posting Buffer"; var NonDeductibleVATPct: Decimal)    begin    end;#if not CLEAN29    [Obsolete('This event is replaced by OnBeforeInsertDeferralNonDeductibleVATGLEntries2.', '29.0')]    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDeferralNonDeductibleVATGLEntries(var NonDeductibleVATPct: Decimal; DeferralPostingBuffer: Record "Deferral Posting Buffer"; VATPostingSetup: Record "VAT Posting Setup"; GenJournalLine: Record "Gen. Journal Line"; DeferralTemplate: Record "Deferral Template"; var VATAmountRounding: Decimal; var PositiveNDVATAmountRounding: Decimal; var NegativeNDVATAmountRounding: Decimal; var IsHandled: Boolean)    begin    end;#endif    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDeferralNonDeductibleVATGLEntries2(var NonDeductibleVATPct: Decimal; DeferralPostingBuffer: Record "Deferral Posting Buffer"; VATPostingSetup: Record "VAT Posting Setup"; GenJournalLine: Record "Gen. Journal Line"; DeferralTemplate: Record "Deferral Template"; var PositiveVATAmountRounding: Decimal; var NegativeVATAmountRounding: Decimal; var PositiveNDVATAmountRounding: Decimal; var NegativeNDVATAmountRounding: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyCustLedgEntryOnAfterUpdateCustLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var NewDetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; CustomerPostingGroup: Record "Customer Posting Group"; var GLEntry: Record "G/L Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCustOnBeforeGetCustomerPostingGroup(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyCustLedgEntryOnBeforeFinishPosting(var GenJournalLine: Record "Gen. Journal Line"; GLEntry: Record "G/L Entry"; CustomerPostingGroup: Record "Customer Posting Group");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostCustOnBeforeInsertDtldCVLedgEntry(var GenJournalLine: Record "Gen. Journal Line"; var TempDetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var CustLedgerEntry: Record "Cust. Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldCustLedgEntriesOnBeforeNextEntryNo(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; CustomerPostingGroup: Record "Customer Posting Group"; LedgEntryInserted: Boolean; var NextEntryNo: Integer; var SavedEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostBankAccOnCheckingBankAccPostingGrGLAccountNo(var GenJournalLine: Record "Gen. Journal Line"; BankAccPostingGr: Record "Bank Account Posting Group"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostDtldCustLedgEntries(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; CustomerPostingGroup: Record "Customer Posting Group"; LedgEntryInserted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInitGLEntryOnBeforeCheckGLAccountBlocked(GenJournalLine: Record "Gen. Journal Line"; GLAccount: Record "G/L Account"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyCustLedgEntryOnAfterGetNextDtldLedgEntryNo(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldCustLedgEntriesOnAfterSetDtldCustLedgEntryNoOffset(var GenJournalLine: Record "Gen. Journal Line"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; CustomerPostingGroup: Record "Customer Posting Group"; LedgEntryInserted: Boolean; var NextEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostApplyOnAfterCalcCurrencyApplnRounding(GenJournalLine: Record "Gen. Journal Line"; var NewCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var NewCVLedgerEntryBuffer2: Record "CV Ledger Entry Buffer"; var OldCVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var OldCVLedgerEntryBuffer2: Record "CV Ledger Entry Buffer"; var DetailedCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var AppliedAmount: Decimal; var PmtTolAmtToBeApplied: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustPostApplyCustLedgEntryOnBeforeApplyCustLedgEntry(var CustLedgerEntry: Record "Cust. Ledger Entry"; GenJournalLine: Record "Gen. Journal Line"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustPostApplyCustLedgEntryOnBeforeModifyCustLedgEntry(var CustLedgerEntry: Record "Cust. Ledger Entry"; var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustPostApplyCustLedgEntryOnBeforeCheckPostUnrealizedVAT(var GenJournalLine: Record "Gen. Journal Line"; var DtldCVLedgEntryBuffer: Record "Detailed CV Ledg. Entry Buffer"; var DtldLedgEntryInserted: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnOnUnapplyCustLedgEntryOnBeforeProcessDetailedCustLedgEntry2InLoop(DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldVendLedgEntriesOnBeforeSetDtldVendLedgEntryNoOffset(var GenJournalLine: Record "Gen. Journal Line"; var DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDtldVendLedgEntriesOnAfterSetDtldVendLedgEntryNoOffset(var GenJournalLine: Record "Gen. Journal Line"; var DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; var DtldVendLedgEntryNoOffset: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnVendUnrealizedVATOnBeforeGetUnrealizedVATPart(var GenJournalLine: Record "Gen. Journal Line"; var VendorLedgerEntry: Record "Vendor Ledger Entry"; PaidAmount: Decimal; TotalUnrealVATAmountFirst: Decimal; TotalUnrealVATAmountLast: Decimal; SettledAmount: Decimal; VATEntry2: Record "VAT Entry"; var VATPart: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCustUnrealizedVATOnBeforeGetUnrealizedVATPart(var GenJournalLine: Record "Gen. Journal Line"; var CustLedgerEntry: Record "Cust. Ledger Entry"; PaidAmount: Decimal; TotalUnrealVATAmountFirst: Decimal; TotalUnrealVATAmountLast: Decimal; SettledAmount: Decimal; VATEntry2: Record "VAT Entry"; var VATPart: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSetAppliedAmountFromRemainingAmount(var CVLedgEntryBuffer: Record "CV Ledger Entry Buffer"; var AppliedAmount: Decimal; var GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSetAppliedAmountFromRemainingAmountOnEmptyFilter(var CVLedgerEntryBuffer: Record "CV Ledger Entry Buffer"; var AppliedAmount: Decimal; var GenJnlLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtDiscBeforeInitDetailedCVLedgEntryBuff(var GenJnlLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcPmtDiscToleranceBeforeInitDetailedCVLedgEntryBuff(var GenJnlLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckDetVendLedgEntryMultiplePostingGrOnBeforeUnapply(var DetailedVendorLedgEntry2: Record "Detailed Vendor Ledg. Entry"; var DetailedVendorLedgEntry: Record "Detailed Vendor Ledg. Entry"; var MultiplePostingGroupsDetected: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckDetCustLedgEntryMultiplePostingGrOnBeforeUnapply(var DetailedCustLedgEntry2: Record "Detailed Cust. Ledg. Entry"; var DetailedCustLedgEntry: Record "Detailed Cust. Ledg. Entry"; var MultiplePostingGroupsDetected: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostBankAccOnBeforeCheckCurrencyCode(var GenJournalLine: Record "Gen. Journal Line"; BankAccount: Record "Bank Account"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateNormalVATGLEntries(GenJournalLine: Record "Gen. Journal Line"; var VATPostingSetup: Record "VAT Posting Setup")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostCust(var GenJournalLine: Record "Gen. Journal Line"; Balancing: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitNextEntryNo(var GLEntry: Record "G/L Entry"; var NextEntryNo: Integer; var NextTransactionNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitNextEntryNo(var GLEntry: Record "G/L Entry"; var NextEntryNo: Integer; var NextTransactionNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostDeferralOnAfterGetNonDeductibleVATPct(GenJournalLine: Record "Gen. Journal Line"; DeferralDocType: Enum "Deferral Document Type"; var NonDeductibleVATPct: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterGetGLSetup(var GLSetup: Record "General Ledger Setup"; var GLSetupRead: Boolean; AddCurrencyCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterSetDtldEmplLedgEntryNoOffset(var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; var DtldCustLedgEntryNoOffset: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnUnapplyEmplLedgEntryOnAfterFilterSourceEntries(var DetailedEmployeeLedgEntry: Record "Detailed Employee Ledger Entry"; var DetailedEmployeeLedgEntry2: Record "Detailed Employee Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckBankAccPostingGroup(GeneralLedgerSetup: Record "General Ledger Setup"; GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCheckGLAccDimError(GenJournalLine: Record "Gen. Journal Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitDetailedCVLedgEntryBufCalcPmtTolerance(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var DtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer"; GenJnlLine: Record "Gen. Journal Line"; var PmtTolAmtToBeApplied: Decimal; NextTransactionNo: Integer; FirstNewVATEntryNo: Integer; var PmtTol: Decimal; var PmtTolLCY: Decimal; var PmtTolAddCurr: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnCodeOnAfterCheckGenJnlLine(var GenJnlLine: Record "Gen. Journal Line"; CheckLine: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeCreateGLEntriesForTotalAmountsUnapplyEmployee(DetailedEmployeeLedgerEntry: Record "Detailed Employee Ledger Entry"; var EmployeePostingGroup: Record "Employee Posting Group"; GenJournalLine: Record "Gen. Journal Line"; var TempDimPostingBuffer: Record "Dimension Posting Buffer" temporary; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeIncrNextVATEntryNo(var NextVATEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeIncrNextEntryNo(var NextEntryNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostApplyOnAfterFindAmtForApplnOnBeforeCalcCurrencyUnrealizedGainLoss(var NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; var OldCVLedgEntryBuf2: Record "CV Ledger Entry Buffer"; var AppliedAmount: Decimal; var AppliedAmountLCY: Decimal; var OldAppliedAmount: Decimal; var ApplnRoundingPrecision: Decimal; var VATEntry: Record "VAT Entry")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforeInitGLEntryForGLAcc(GenJnlLine: Record "Gen. Journal Line"; GLAcc: Record "G/L Account"; var GLEntry: Record "G/L Entry"; var TaxAmount: Decimal; var TaxAmountLCY: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnBeforePostingDeferral(GenJnlLine: Record "Gen. Journal Line"; VendLedgEntry: Record "Vendor Ledger Entry"; TaxAmount: Decimal; TaxAmountLCY: Decimal; NextTransactionNo: Integer; var NextTaxEntryNo: Integer; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeBankAccLedgEntryUpdateAmounts(var BankAccountLedgerEntry: Record "Bank Account Ledger Entry"; var GenJournalLine: Record "Gen. Journal Line"; BankAccount: Record "Bank Account"; TaxAmount: Decimal; TaxAmountLCY: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCopyFromCVLedgEntryBuffer(var GenJnlLine: Record "Gen. Journal Line"; OldVendLedgEntry: Record "Vendor Ledger Entry"; TempOldVendLedgEntry: Record "Vendor Ledger Entry" temporary; var OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; NewCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; AppliedAmount: Decimal; var RemainingTaxAmount: Decimal; NextTransactionNo: Integer; var NextTaxEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateOldVendLedgEntryAmountToApply(GenJnlLine: Record "Gen. Journal Line"; var OldVendLedgEntry: Record "Vendor Ledger Entry"; OldCVLedgEntryBuf: Record "CV Ledger Entry Buffer"; RemainingTaxAmount: Decimal; AppliedAmount: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnStartPostingOnAfterSetNextTaxEntryNo(var NextTaxEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostUnapplyOnBeforeInsertTempVATEntry(var VATEntry: Record "VAT Entry"; var UnapplyVATEntries: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostEmployeeOnAfterInitEmployeeLedgerEntry(var GenJnlLine: Record "Gen. Journal Line"; var EmployeeLedgerEntry: Record "Employee Ledger Entry"; Employee: Record Employee; var TaxAmount: Decimal; var TaxBaseAmount: Decimal)    begin    end;    [IntegrationEvent(true, false)]    local procedure OnAfterPostEmployee(GenJnlLine: Record "Gen. Journal Line"; EmployeeLedgerEntry: Record "Employee Ledger Entry"; TaxAmount: Decimal; TaxBaseAmount: Decimal; NextTransactionNo: Integer; var NextTaxEntryNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostEmployeeAfterTempDtldCVLedgEntryBufInit(var GenJnlLine: Record "Gen. Journal Line"; var TempDtldCVLedgEntryBuf: Record "Detailed CV Ledg. Entry Buffer" temporary; TaxAmount: Decimal; TaxBaseAmount: Decimal)    begin    end;}