Codeunit 1720 Deferral Utilities
src/Layers/W1/BaseApp/Finance/Deferral/DeferralUtilities.Codeunit.al2,086 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.Deferral;using Microsoft.Bank.BankAccount;using Microsoft.Finance.Currency;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Posting;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Foundation.AuditCodes;using Microsoft.Foundation.Period;using Microsoft.Purchases.Document;using Microsoft.Purchases.Vendor;using Microsoft.Sales.Customer;using System.Security.User;/// <summary>/// Central utility functions for deferral processing including schedule creation, calculation methods, and posting operations./// Handles all core deferral business logic and integrates with various document types and posting routines./// </summary>codeunit 1720 "Deferral Utilities"{ trigger OnRun() begin end; var GenJnlCheckLine: Codeunit "Gen. Jnl.-Check Line"; AmountRoundingPrecision: Decimal; InvalidPostingDateErr: Label '%1 is not within the range of posting dates for your company.', Comment = '%1=The date passed in for the posting date.'; DeferSchedOutOfBoundsErr: Label 'The deferral schedule falls outside the accounting periods that have been set up for the company.'; SelectDeferralCodeMsg: Label 'A deferral code must be selected for the line to view the deferral schedule.'; DescriptionTok: Label '%1-%2', Locked = true; /// <summary> /// Creates a period-specific description by substituting placeholders with actual date values. /// Supports day, week, month, month text, accounting period name, and year placeholders. /// </summary> /// <param name="PostingDate">The posting date to extract date components from</param> /// <param name="Description">Template description with placeholders (%1=Day, %2=Week, %3=Month, %4=Month Text, %5=Period Name, %6=Year)</param> /// <returns>Final description with placeholders replaced by actual values</returns> procedure CreateRecurringDescription(PostingDate: Date; Description: Text[100]) FinalDescription: Text[100] var AccountingPeriod: Record "Accounting Period"; Day: Integer; Week: Integer; Month: Integer; Year: Integer; MonthText: Text[30]; begin Day := Date2DMY(PostingDate, 1); Week := Date2DWY(PostingDate, 2); Month := Date2DMY(PostingDate, 2); MonthText := Format(PostingDate, 0, '<Month Text>'); Year := Date2DMY(PostingDate, 3); if IsAccountingPeriodExist(AccountingPeriod, PostingDate) then begin AccountingPeriod.SetRange("Starting Date", 0D, PostingDate); if not AccountingPeriod.FindLast() then AccountingPeriod.Name := ''; end; FinalDescription := CopyStr(StrSubstNo(Description, Day, Week, Month, MonthText, AccountingPeriod.Name, Year), 1, MaxStrLen(Description)); end; /// <summary> /// Creates a complete deferral schedule based on the specified parameters and calculation method. /// Generates header and line records with amounts distributed according to the selected calculation method. /// </summary> /// <param name="DeferralCode">Deferral template code defining calculation parameters</param> /// <param name="DeferralDocType">Type of source document (Purchase, Sales, G/L)</param> /// <param name="GenJnlTemplateName">General Journal Template name for G/L deferrals</param> /// <param name="GenJnlBatchName">General Journal Batch name for G/L deferrals</param> /// <param name="DocumentType">Document type ID from the source document</param> /// <param name="DocumentNo">Document number from the source document</param> /// <param name="LineNo">Line number within the source document</param> /// <param name="AmountToDefer">Total amount to be deferred</param> /// <param name="CalcMethod">Method for calculating period amounts (Straight-Line, Equal per Period, etc.)</param> /// <param name="StartDate">Date to start the deferral schedule</param> /// <param name="NoOfPeriods">Number of periods to distribute the deferral over</param> /// <param name="ApplyDeferralPercentage">Whether to apply the deferral percentage from the template</param> /// <param name="DeferralDescription">Description for the deferral schedule</param> /// <param name="AdjustStartDate">Whether to adjust start date based on template settings</param> /// <param name="CurrencyCode">Currency code for foreign currency handling</param> procedure CreateDeferralSchedule(DeferralCode: Code[10]; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer; AmountToDefer: Decimal; CalcMethod: Enum "Deferral Calculation Method"; StartDate: Date; NoOfPeriods: Integer; ApplyDeferralPercentage: Boolean; DeferralDescription: Text[100]; AdjustStartDate: Boolean; CurrencyCode: Code[10]) var DeferralTemplate: Record "Deferral Template"; DeferralHeader: Record "Deferral Header"; DeferralLine: Record "Deferral Line"; DeferralLineAmount: Dictionary of [RecordId, Decimal]; AdjustedStartDate: Date; AdjustedDeferralAmount: Decimal; TotalDeferralLineAmount: Decimal; IsHandled: Boolean; RedistributeDeferralSchedule: Boolean; begin IsHandled := false; OnBeforeCreateDeferralSchedule( DeferralCode, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo, AmountToDefer, CalcMethod, StartDate, NoOfPeriods, ApplyDeferralPercentage, DeferralDescription, AdjustStartDate, CurrencyCode, IsHandled, RedistributeDeferralSchedule); if IsHandled then exit; InitCurrency(CurrencyCode); DeferralTemplate.Get(DeferralCode); // "Start Date" passed in needs to be adjusted based on the Deferral Code's Start Date setting if AdjustStartDate then AdjustedStartDate := SetStartDate(DeferralTemplate, StartDate) else AdjustedStartDate := StartDate; AdjustedDeferralAmount := AmountToDefer; if ApplyDeferralPercentage then AdjustedDeferralAmount := Round(AdjustedDeferralAmount * (DeferralTemplate."Deferral %" / 100), AmountRoundingPrecision); if RedistributeDeferralSchedule then SaveUserDefinedDeferralLineAmounts( DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo, CalcMethod, DeferralLineAmount, TotalDeferralLineAmount); SetDeferralRecords( DeferralHeader, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo, CalcMethod, NoOfPeriods, AdjustedDeferralAmount, AdjustedStartDate, DeferralCode, DeferralDescription, AmountToDefer, AdjustStartDate, CurrencyCode); case CalcMethod of CalcMethod::"Straight-Line": CalculateStraightline(DeferralHeader, DeferralLine, DeferralTemplate); CalcMethod::"Equal per Period": CalculateEqualPerPeriod(DeferralHeader, DeferralLine, DeferralTemplate); CalcMethod::"Days per Period": CalculateDaysPerPeriod(DeferralHeader, DeferralLine, DeferralTemplate); CalcMethod::"User-Defined": CalculateUserDefined(DeferralHeader, DeferralLine, DeferralTemplate); else OnCreateDeferralScheduleOnCalcMethodElse(CalcMethod, DeferralHeader, DeferralLine, DeferralTemplate); end; if RedistributeDeferralSchedule then RedistributeDeferralLines(DeferralLine, DeferralLineAmount, DeferralHeader, TotalDeferralLineAmount); RoundDeferralAmountFromSource(DeferralHeader); OnAfterCreateDeferralSchedule(DeferralHeader, DeferralLine, DeferralTemplate, CalcMethod); end; local procedure RoundDeferralAmountFromSource(var DeferralHeader: Record "Deferral Header") var PurchaseHeader: Record "Purchase Header"; AmtToDefer: Decimal; AmtToDeferLCY: Decimal; begin case DeferralHeader."Deferral Doc. Type" of DeferralHeader."Deferral Doc. Type"::Purchase: begin PurchaseHeader.SetLoadFields("Currency Factor", "Posting Date", "Currency Code"); if not PurchaseHeader.Get(DeferralHeader."Document Type", DeferralHeader."Document No.") then exit; RoundDeferralAmount( DeferralHeader, DeferralHeader."Currency Code", PurchaseHeader."Currency Factor", PurchaseHeader."Posting Date", AmtToDefer, AmtToDeferLCY); end; end; end; local procedure SaveUserDefinedDeferralLineAmounts(DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer; CalcMethod: Enum "Deferral Calculation Method"; var DeferralLineAmount: Dictionary of [RecordId, Decimal]; var TotalDeferralLineAmount: Decimal) var DeferralHeader: Record "Deferral Header"; DeferralLine: Record "Deferral Line"; begin if CalcMethod <> CalcMethod::"User-Defined" then exit; if not DeferralHeader.Get(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo) then exit; FilterDeferralLines(DeferralLine, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo); DeferralLine.SetFilter(Amount, '<>0'); if DeferralLine.IsEmpty() then exit; Clear(DeferralLineAmount); SaveDeferralLineAmounts(DeferralLine, DeferralLineAmount); DeferralLine.CalcSums(Amount); TotalDeferralLineAmount := DeferralLine.Amount; end; local procedure SaveDeferralLineAmounts(var DeferralLine: Record "Deferral Line"; var DeferralLineAmount: Dictionary of [RecordId, Decimal]) begin if DeferralLine.FindSet() then repeat DeferralLineAmount.Add(DeferralLine.RecordId, DeferralLine.Amount); until DeferralLine.Next() = 0; end; local procedure RedistributeDeferralLines(var DeferralLine: Record "Deferral Line"; DeferralLineAmount: Dictionary of [RecordId, Decimal]; DeferralHeader: Record "Deferral Header"; InitialAmountToDefer: Decimal) var InitialDeferralLineAmount: Decimal; TotalDeferralLineAmount: Decimal; begin if DeferralLineAmount.Count = 0 then exit; FilterDeferralLines(DeferralLine, DeferralHeader."Deferral Doc. Type".AsInteger(), DeferralHeader."Gen. Jnl. Template Name", DeferralHeader."Gen. Jnl. Batch Name", DeferralHeader."Document Type", DeferralHeader."Document No.", DeferralHeader."Line No."); if DeferralLine.FindSet(true) then repeat if DeferralLineAmount.ContainsKey(DeferralLine.RecordId) then begin InitialDeferralLineAmount := DeferralLineAmount.Get(DeferralLine.RecordId); DeferralLine.Validate(Amount, Round(DeferralHeader."Amount to Defer" / InitialAmountToDefer * InitialDeferralLineAmount, AmountRoundingPrecision)); DeferralLine.Modify(true); TotalDeferralLineAmount += DeferralLine.Amount; end; until DeferralLine.Next() = 0; if TotalDeferralLineAmount = DeferralHeader."Amount to Defer" then exit; DeferralLine.Validate(Amount, DeferralLine.Amount + DeferralHeader."Amount to Defer" - TotalDeferralLineAmount); DeferralLine.Modify(true); end; /// <summary> /// Calculates the actual number of deferral periods based on the calculation method and parameters. /// For user-defined methods, returns the number of existing deferral lines instead of the parameter value. /// </summary> /// <param name="CalcMethod">Calculation method (Straight-Line, Equal per Period, Days per Period, User-Defined)</param> /// <param name="NoOfPeriods">Number of periods specified in the deferral setup</param> /// <param name="StartDate">Start date for the deferral schedule</param> /// <returns>Actual number of periods that will be created for the deferral schedule</returns> procedure CalcDeferralNoOfPeriods(CalcMethod: Enum "Deferral Calculation Method"; NoOfPeriods: Integer; StartDate: Date): Integer var DeferralTemplate: Record "Deferral Template"; AccountingPeriod: Record "Accounting Period"; IsHandled: Boolean; begin IsHandled := false; OnBeforeCalcDeferralNoOfPeriods(CalcMethod, NoOfPeriods, StartDate, IsHandled); if IsHandled then exit(NoOfPeriods); case CalcMethod of DeferralTemplate."Calc. Method"::"Equal per Period", DeferralTemplate."Calc. Method"::"User-Defined": exit(NoOfPeriods); DeferralTemplate."Calc. Method"::"Straight-Line", DeferralTemplate."Calc. Method"::"Days per Period": begin if IsAccountingPeriodExist(AccountingPeriod, StartDate) then begin AccountingPeriod.SetFilter("Starting Date", '>=%1', StartDate); AccountingPeriod.FindFirst(); end; if AccountingPeriod."Starting Date" = StartDate then exit(NoOfPeriods); exit(NoOfPeriods + 1); end; end; DeferralTemplate."Calc. Method" := CalcMethod; DeferralTemplate.FieldError("Calc. Method"); end; local procedure CalculateStraightline(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") var AccountingPeriod: Record "Accounting Period"; AmountToDefer: Decimal; AmountToDeferFirstPeriod: Decimal; FractionOfPeriod: Decimal; PeriodicDeferralAmount: Decimal; RunningDeferralTotal: Decimal; NoOfLoops: Integer; PeriodicCount: Integer; HowManyDaysLeftInPeriod: Integer; NumberOfDaysInPeriod: Integer; PostDate: Date; FirstPeriodDate: Date; SecondPeriodDate: Date; PerDiffSum: Decimal; IsHandled: Boolean; begin // If the Start Date passed in matches the first date of a financial period, this is essentially the same // as the "Equal Per Period" deferral method, so call that function. OnBeforeCalculateStraightline(DeferralHeader, DeferralLine, DeferralTemplate); if IsAccountingPeriodExist(AccountingPeriod, DeferralHeader."Start Date") then begin AccountingPeriod.SetFilter("Starting Date", '>=%1', DeferralHeader."Start Date"); if not AccountingPeriod.FindFirst() then Error(DeferSchedOutOfBoundsErr); end; IsHandled := false; OnCalculateStraightlineOnBeforeCalcPeriodicDeferralAmount(DeferralHeader, PeriodicDeferralAmount, AmountRoundingPrecision, IsHandled); if not IsHandled then begin if AccountingPeriod."Starting Date" = DeferralHeader."Start Date" then begin CalculateEqualPerPeriod(DeferralHeader, DeferralLine, DeferralTemplate); exit; end; PeriodicDeferralAmount := Round(DeferralHeader."Amount to Defer" / DeferralHeader."No. of Periods", AmountRoundingPrecision); end; NoOfLoops := DeferralHeader."No. of Periods" + 1; OnCalculateStraightlineOnAfterCalcPeriodicDeferralAmount(DeferralHeader, NoOfLoops); for PeriodicCount := 1 to NoOfLoops do begin InitializeDeferralHeaderAndSetPostDate(DeferralLine, DeferralHeader, PeriodicCount, PostDate); if (PeriodicCount = 1) or (PeriodicCount = NoOfLoops) then begin if PeriodicCount = 1 then begin Clear(RunningDeferralTotal); // Get the starting date of the accounting period of the posting date is in FirstPeriodDate := GetPeriodStartingDate(PostDate); // Get the starting date of the next accounting period SecondPeriodDate := GetNextPeriodStartingDate(PostDate); OnCalculateStraightlineOnAfterCalcSecondPeriodDate(DeferralHeader, PostDate, FirstPeriodDate, SecondPeriodDate); HowManyDaysLeftInPeriod := (SecondPeriodDate - DeferralHeader."Start Date"); NumberOfDaysInPeriod := (SecondPeriodDate - FirstPeriodDate); FractionOfPeriod := (HowManyDaysLeftInPeriod / NumberOfDaysInPeriod); AmountToDeferFirstPeriod := (PeriodicDeferralAmount * FractionOfPeriod); AmountToDefer := Round(AmountToDeferFirstPeriod, AmountRoundingPrecision); RunningDeferralTotal := RunningDeferralTotal + AmountToDefer; end else // Last period AmountToDefer := (DeferralHeader."Amount to Defer" - RunningDeferralTotal); end else begin AmountToDefer := Round(PeriodicDeferralAmount, AmountRoundingPrecision); RunningDeferralTotal := RunningDeferralTotal + AmountToDefer; end; DeferralLine."Posting Date" := PostDate; UpdateDeferralLineDescription(DeferralLine, DeferralHeader, DeferralTemplate, PostDate); CheckPostingDate(DeferralHeader, DeferralLine); PerDiffSum := PerDiffSum + Round(AmountToDefer / DeferralHeader."No. of Periods", AmountRoundingPrecision); DeferralLine.Amount := AmountToDefer; OnCalculateStraightlineOnBeforeDeferralLineInsert(DeferralLine, DeferralHeader); DeferralLine.Insert(); end; OnAfterCalculateStraightline(DeferralHeader, DeferralLine, DeferralTemplate); end; local procedure CheckPostingDate(DeferralHeader: Record "Deferral Header"; DeferralLine: Record "Deferral Line") var GenJournalBatch: Record "Gen. Journal Batch"; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckPostingDate(DeferralHeader, DeferralLine, IsHandled); if IsHandled then exit; if GenJournalBatch.Get(DeferralHeader."Gen. Jnl. Template Name", DeferralHeader."Gen. Jnl. Batch Name") then GenJnlCheckLine.SetGenJnlBatch(GenJournalBatch); if GenJnlCheckLine.DeferralPostingDateNotAllowed(DeferralLine."Posting Date") then Error(InvalidPostingDateErr, DeferralLine."Posting Date"); end; local procedure CalculateEqualPerPeriod(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") var PeriodicCount: Integer; PostDate: Date; AmountToDefer: Decimal; RunningDeferralTotal: Decimal; begin OnBeforeCalculateEqualPerPeriod(DeferralHeader, DeferralLine, DeferralTemplate); for PeriodicCount := 1 to DeferralHeader."No. of Periods" do begin InitializeDeferralHeaderAndSetPostDate(DeferralLine, DeferralHeader, PeriodicCount, PostDate); DeferralLine.Validate("Posting Date", PostDate); UpdateDeferralLineDescription(DeferralLine, DeferralHeader, DeferralTemplate, PostDate); AmountToDefer := DeferralHeader."Amount to Defer"; if PeriodicCount = 1 then Clear(RunningDeferralTotal); if PeriodicCount <> DeferralHeader."No. of Periods" then begin AmountToDefer := Round(AmountToDefer / DeferralHeader."No. of Periods", AmountRoundingPrecision); RunningDeferralTotal := RunningDeferralTotal + AmountToDefer; end else AmountToDefer := (DeferralHeader."Amount to Defer" - RunningDeferralTotal); DeferralLine.Amount := AmountToDefer; OnCalculateEqualPerPeriodOnBeforeDeferralLineInsert(DeferralHeader, DeferralLine); DeferralLine.Insert(); end; OnAfterCalculateEqualPerPeriod(DeferralHeader, DeferralLine, DeferralTemplate); end; local procedure CalculateDaysPerPeriod(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") var AccountingPeriod: Record "Accounting Period"; AmountToDefer: Decimal; PeriodicCount: Integer; NumberOfDaysInPeriod: Integer; NumberOfDaysInSchedule: Integer; NumberOfDaysIntoCurrentPeriod: Integer; NumberOfPeriods: Integer; PostDate: Date; FirstPeriodDate: Date; SecondPeriodDate: Date; EndDate: Date; TempDate: Date; NoExtraPeriod: Boolean; DailyDeferralAmount: Decimal; RunningDeferralTotal: Decimal; begin OnBeforeCalculateDaysPerPeriod(DeferralHeader, DeferralLine, DeferralTemplate); if IsAccountingPeriodExist(AccountingPeriod, DeferralHeader."Start Date") then begin AccountingPeriod.SetFilter("Starting Date", '>=%1', DeferralHeader."Start Date"); if not AccountingPeriod.FindFirst() then Error(DeferSchedOutOfBoundsErr); end; if AccountingPeriod."Starting Date" = DeferralHeader."Start Date" then NoExtraPeriod := true else NoExtraPeriod := false; // If comparison used <=, it messes up the calculations if not NoExtraPeriod then begin if IsAccountingPeriodExist(AccountingPeriod, DeferralHeader."Start Date") then begin AccountingPeriod.SetFilter("Starting Date", '<%1', DeferralHeader."Start Date"); AccountingPeriod.FindLast(); end; NumberOfDaysIntoCurrentPeriod := (DeferralHeader."Start Date" - AccountingPeriod."Starting Date"); end else NumberOfDaysIntoCurrentPeriod := 0; if NoExtraPeriod then NumberOfPeriods := DeferralHeader."No. of Periods" else NumberOfPeriods := (DeferralHeader."No. of Periods" + 1); for PeriodicCount := 1 to NumberOfPeriods do begin // Figure out the end date... if PeriodicCount = 1 then TempDate := DeferralHeader."Start Date"; if PeriodicCount <> NumberOfPeriods then TempDate := GetNextPeriodStartingDate(TempDate) else // Last Period, special case here... if NoExtraPeriod then begin TempDate := GetNextPeriodStartingDate(TempDate); EndDate := TempDate; end else EndDate := (TempDate + NumberOfDaysIntoCurrentPeriod); end; OnCalculateDaysPerPeriodOnAfterCalcEndDate(DeferralHeader, DeferralLine, DeferralTemplate, EndDate); NumberOfDaysInSchedule := (EndDate - DeferralHeader."Start Date"); DailyDeferralAmount := (DeferralHeader."Amount to Defer" / NumberOfDaysInSchedule); for PeriodicCount := 1 to NumberOfPeriods do begin InitializeDeferralHeaderAndSetPostDate(DeferralLine, DeferralHeader, PeriodicCount, PostDate); if PeriodicCount = 1 then begin Clear(RunningDeferralTotal); FirstPeriodDate := DeferralHeader."Start Date"; // Get the starting date of the next accounting period SecondPeriodDate := GetNextPeriodStartingDate(PostDate); NumberOfDaysInPeriod := (SecondPeriodDate - FirstPeriodDate); AmountToDefer := Round(NumberOfDaysInPeriod * DailyDeferralAmount, AmountRoundingPrecision); RunningDeferralTotal := RunningDeferralTotal + AmountToDefer; end else begin // Get the starting date of the accounting period of the posting date is in FirstPeriodDate := GetCurPeriodStartingDate(PostDate); // Get the starting date of the next accounting period SecondPeriodDate := GetNextPeriodStartingDate(PostDate); NumberOfDaysInPeriod := (SecondPeriodDate - FirstPeriodDate); if PeriodicCount <> NumberOfPeriods then begin // Not the last period AmountToDefer := Round(NumberOfDaysInPeriod * DailyDeferralAmount, AmountRoundingPrecision); RunningDeferralTotal := RunningDeferralTotal + AmountToDefer; end else AmountToDefer := (DeferralHeader."Amount to Defer" - RunningDeferralTotal); end; DeferralLine."Posting Date" := PostDate; UpdateDeferralLineDescription(DeferralLine, DeferralHeader, DeferralTemplate, PostDate); CheckPostingDate(DeferralHeader, DeferralLine); DeferralLine.Amount := AmountToDefer; OnCalculateDaysPerPeriodOnBeforeDeferralLineInsert(DeferralHeader, DeferralLine); DeferralLine.Insert(); end; OnAfterCalculateDaysPerPeriod(DeferralHeader, DeferralLine, DeferralTemplate); end; local procedure CalculateUserDefined(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") var PeriodicCount: Integer; PostDate: Date; begin OnBeforeCalculateUserDefined(DeferralHeader, DeferralLine, DeferralTemplate); for PeriodicCount := 1 to DeferralHeader."No. of Periods" do begin InitializeDeferralHeaderAndSetPostDate(DeferralLine, DeferralHeader, PeriodicCount, PostDate); DeferralLine."Posting Date" := PostDate; UpdateDeferralLineDescription(DeferralLine, DeferralHeader, DeferralTemplate, PostDate); CheckPostingDate(DeferralHeader, DeferralLine); // For User-Defined, user must enter in deferral amounts OnCalculateUserDefinedOnBeforeDeferralLineInsert(DeferralHeader, DeferralLine); DeferralLine.Insert(); end; OnAfterCalculateUserDefined(DeferralHeader, DeferralLine, DeferralTemplate); end; local procedure UpdateDeferralLineDescription(var DeferralLine: Record "Deferral Line"; DeferralHeader: Record "Deferral Header"; DeferralTemplate: Record "Deferral Template"; PostDate: Date) var IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateDeferralLineDescription(DeferralLine, DeferralHeader, DeferralTemplate, PostDate, IsHandled); if IsHandled then exit; DeferralLine.Description := CreateRecurringDescription(PostDate, DeferralTemplate."Period Description"); end; /// <summary> /// Sets filters on the deferral line record to retrieve lines for a specific source document. /// Used throughout the deferral system to isolate deferral lines by their source document parameters. /// </summary> /// <param name="DeferralLine">Deferral Line record reference to apply filters to</param> /// <param name="DeferralDocType">Type of source document (Purchase, Sales, G/L)</param> /// <param name="GenJnlTemplateName">General Journal Template name for G/L deferrals</param> /// <param name="GenJnlBatchName">General Journal Batch name for G/L deferrals</param> /// <param name="DocumentType">Document type ID from the source document</param> /// <param name="DocumentNo">Document number from the source document</param> /// <param name="LineNo">Line number within the source document</param> procedure FilterDeferralLines(var DeferralLine: Record "Deferral Line"; DeferralDocType: Option; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer) begin DeferralLine.SetRange("Deferral Doc. Type", DeferralDocType); DeferralLine.SetRange("Gen. Jnl. Template Name", GenJnlTemplateName); DeferralLine.SetRange("Gen. Jnl. Batch Name", GenJnlBatchName); DeferralLine.SetRange("Document Type", DocumentType); DeferralLine.SetRange("Document No.", DocumentNo); DeferralLine.SetRange("Line No.", LineNo); end; /// <summary> /// Checks if the specified posting date is allowed for deferral posting based on user and general ledger setup. /// </summary> /// <param name="PostingDate">Date to validate for deferral posting</param> /// <returns>True if the date is not allowed, false if it is allowed</returns> procedure IsDateNotAllowed(PostingDate: Date) Result: Boolean var GeneralLedgerSetup: Record "General Ledger Setup"; UserSetup: Record "User Setup"; AllowPostingFrom: Date; AllowPostingTo: Date; IsHandled: Boolean; begin OnBeforeIsDateNotAllowed(PostingDate, Result, IsHandled); if IsHandled then exit(Result); if UserId() <> '' then if UserSetup.Get(UserId()) then begin UserSetup.CheckAllowedDeferralPostingDates(1); AllowPostingFrom := UserSetup."Allow Deferral Posting From"; AllowPostingTo := UserSetup."Allow Deferral Posting To"; end; if (AllowPostingFrom = 0D) and (AllowPostingTo = 0D) then begin GeneralLedgerSetup.Get(); GeneralLedgerSetup.CheckAllowedDeferralPostingDates(1); AllowPostingFrom := GeneralLedgerSetup."Allow Deferral Posting From"; AllowPostingTo := GeneralLedgerSetup."Allow Deferral Posting To"; end; if AllowPostingTo = 0D then AllowPostingTo := DMY2Date(31, 12, 9999); Result := not (PostingDate in [AllowPostingFrom .. AllowPostingTo]); end; local procedure SetStartDate(DeferralTemplate: Record "Deferral Template"; StartDate: Date) AdjustedStartDate: Date var AccountingPeriod: Record "Accounting Period"; DeferralStartDate: Enum "Deferral Calculation Start Date"; begin // "Start Date" passed in needs to be adjusted based on the Deferral Code's Start Date setting; case DeferralTemplate."Start Date" of DeferralStartDate::"Posting Date": AdjustedStartDate := StartDate; DeferralStartDate::"Beginning of Period": begin if AccountingPeriod.IsEmpty() then exit(CalcDate('<-CM>', StartDate)); AccountingPeriod.SetRange("Starting Date", 0D, StartDate); if AccountingPeriod.FindLast() then AdjustedStartDate := AccountingPeriod."Starting Date"; end; DeferralStartDate::"End of Period": begin if AccountingPeriod.IsEmpty() then exit(CalcDate('<CM>', StartDate)); AccountingPeriod.SetFilter("Starting Date", '>%1', StartDate); if AccountingPeriod.FindFirst() then AdjustedStartDate := CalcDate('<-1D>', AccountingPeriod."Starting Date"); end; DeferralStartDate::"Beginning of Next Period": begin if AccountingPeriod.IsEmpty() then exit(CalcDate('<CM + 1D>', StartDate)); AccountingPeriod.SetFilter("Starting Date", '>%1', StartDate); if AccountingPeriod.FindFirst() then AdjustedStartDate := AccountingPeriod."Starting Date"; end; DeferralStartDate::"Beginning of Next Calendar Year": AdjustedStartDate := CalcDate('<CY + 1D>', StartDate); end; OnAfterSetStartDate(DeferralTemplate, StartDate, AdjustedStartDate); end; /// <summary> /// Creates or updates a deferral header record with the specified parameters. /// Handles both new header creation and updating existing headers with new calculation parameters. /// </summary> /// <param name="DeferralHeader">Deferral Header record reference to create or update</param> /// <param name="DeferralDocType">Type of source document (Purchase, Sales, G/L)</param> /// <param name="GenJnlTemplateName">General Journal Template name for G/L deferrals</param> /// <param name="GenJnlBatchName">General Journal Batch name for G/L deferrals</param> /// <param name="DocumentType">Document type ID from the source document</param> /// <param name="DocumentNo">Document number from the source document</param> /// <param name="LineNo">Line number within the source document</param> /// <param name="CalcMethod">Method for calculating period amounts</param> /// <param name="NoOfPeriods">Number of periods to distribute the deferral over</param> /// <param name="AdjustedDeferralAmount">Final deferral amount after percentage application</param> /// <param name="AdjustedStartDate">Final start date after template-based adjustments</param> /// <param name="DeferralCode">Deferral template code</param> /// <param name="DeferralDescription">Description for the deferral schedule</param> /// <param name="AmountToDefer">Original amount to defer before adjustments</param> /// <param name="AdjustStartDate">Whether start date was adjusted</param> /// <param name="CurrencyCode">Currency code for foreign currency handling</param> procedure SetDeferralRecords(var DeferralHeader: Record "Deferral Header"; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer; CalcMethod: Enum "Deferral Calculation Method"; NoOfPeriods: Integer; AdjustedDeferralAmount: Decimal; AdjustedStartDate: Date; DeferralCode: Code[10]; DeferralDescription: Text[100]; AmountToDefer: Decimal; AdjustStartDate: Boolean; CurrencyCode: Code[10]) begin if not DeferralHeader.Get(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo) then begin // Need to create the header record. DeferralHeader."Deferral Doc. Type" := Enum::"Deferral Document Type".FromInteger(DeferralDocType); DeferralHeader."Gen. Jnl. Template Name" := GenJnlTemplateName; DeferralHeader."Gen. Jnl. Batch Name" := GenJnlBatchName; DeferralHeader."Document Type" := DocumentType; DeferralHeader."Document No." := DocumentNo; DeferralHeader."Line No." := LineNo; DeferralHeader.Insert(); end; DeferralHeader."Amount to Defer" := AdjustedDeferralAmount; if AdjustStartDate or (DeferralHeader."Initial Amount to Defer" = 0) then DeferralHeader."Initial Amount to Defer" := AmountToDefer; DeferralHeader."Calc. Method" := CalcMethod; DeferralHeader."Start Date" := AdjustedStartDate; DeferralHeader."No. of Periods" := NoOfPeriods; DeferralHeader."Schedule Description" := DeferralDescription; DeferralHeader."Deferral Code" := DeferralCode; DeferralHeader."Currency Code" := CurrencyCode; OnSetDeferralRecordsOnBeforeDeferralHeaderModify(DeferralHeader); DeferralHeader.Modify(); // Remove old lines as they will be recalculated/recreated RemoveDeferralLines(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo); end; /// <summary> /// Creates, updates, or removes a deferral schedule based on the provided deferral code and parameters. /// If no deferral code is provided, removes any existing schedule. If a code is provided, creates or updates the schedule. /// </summary> /// <param name="DeferralCode">Deferral template code to use, blank to remove schedule</param> /// <param name="DeferralDocType">Type of document containing the deferral</param> /// <param name="GenJnlTemplateName">General Journal Template name for G/L deferrals</param> /// <param name="GenJnlBatchName">General Journal Batch name for G/L deferrals</param> /// <param name="DocumentType">Document type ID from the source document</param> /// <param name="DocumentNo">Document number from the source document</param> /// <param name="LineNo">Line number within the source document</param> /// <param name="Amount">Amount to defer</param> /// <param name="PostingDate">Posting date for the deferral</param> /// <param name="Description">Description for the deferral schedule</param> /// <param name="CurrencyCode">Currency code for foreign currency handling</param> /// <param name="AdjustStartDate">Whether to adjust the start date based on template settings</param> procedure RemoveOrSetDeferralSchedule(DeferralCode: Code[10]; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer; Amount: Decimal; PostingDate: Date; Description: Text[100]; CurrencyCode: Code[10]; AdjustStartDate: Boolean) var DeferralHeader: Record "Deferral Header"; DeferralTemplate: Record "Deferral Template"; OldDeferralPostingDate: Date; UseDeferralCalculationMethod: Enum "Deferral Calculation Method"; UseNoOfPeriods: Integer; IsHandled: Boolean; begin IsHandled := false; OnBeforeRemoveOrSetDeferralSchedule(DeferralCode, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo, Amount, PostingDate, Description, CurrencyCode, AdjustStartDate, IsHandled); if IsHandled then exit; if DeferralCode = '' then // If the user cleared the deferral code, we should remove the saved schedule... if DeferralHeader.Get(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo) then begin DeferralHeader.Delete(); RemoveDeferralLines(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo); end; if DeferralCode <> '' then if LineNo <> 0 then if DeferralTemplate.Get(DeferralCode) then begin ValidateDeferralTemplate(DeferralTemplate); OldDeferralPostingDate := GetDeferralStartDate(DeferralDocType, DocumentType, DocumentNo, LineNo, DeferralCode, PostingDate); if AdjustStartDate and (OldDeferralPostingDate <> PostingDate) then begin AdjustStartDate := false; PostingDate := OldDeferralPostingDate; end; UseDeferralCalculationMethod := DeferralTemplate."Calc. Method"; UseNoOfPeriods := DeferralTemplate."No. of Periods"; DeferralHeader.SetLoadFields("Calc. Method", "No. of Periods"); if DeferralHeader.Get(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo) then begin UseDeferralCalculationMethod := DeferralHeader."Calc. Method"; if DeferralHeader."No. of Periods" >= 1 then UseNoOfPeriods := DeferralHeader."No. of Periods"; end; CreateDeferralSchedule(DeferralCode, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo, Amount, UseDeferralCalculationMethod, PostingDate, UseNoOfPeriods, true, GetDeferralDescription(GenJnlBatchName, DocumentNo, Description), AdjustStartDate, CurrencyCode); end; end; /// <summary> /// Creates posted deferral records from a general journal line's deferral schedule. /// Transfers the deferral header and lines to posted tables and links them to the posted general ledger entry. /// </summary> /// <param name="GenJournalLine">General journal line being posted</param> /// <param name="FirstEntryNo">First G/L entry number created from the journal line</param> procedure CreateScheduleFromGL(GenJournalLine: Record "Gen. Journal Line"; FirstEntryNo: Integer) var DeferralHeader: Record "Deferral Header"; DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template"; PostedDeferralHeader: Record "Posted Deferral Header"; PostedDeferralLine: Record "Posted Deferral Line"; CustomerPostingGroup: Record "Customer Posting Group"; VendorPostingGroup: Record "Vendor Posting Group"; BankAccount: Record "Bank Account"; BankAccountPostingGroup: Record "Bank Account Posting Group"; GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; DeferralAccount: Code[20]; Account: Code[20]; GLAccount: Code[20]; GLAccountType: Enum "Gen. Journal Account Type"; begin if DeferralHeader.Get(DeferralHeader."Deferral Doc. Type"::"G/L", GenJournalLine."Journal Template Name", GenJournalLine."Journal Batch Name", 0, '', GenJournalLine."Line No.") then begin if DeferralTemplate.Get(DeferralHeader."Deferral Code") then DeferralAccount := DeferralTemplate."Deferral Account"; if (GenJournalLine."Account No." = '') and (GenJournalLine."Bal. Account No." <> '') then begin GLAccount := GenJournalLine."Bal. Account No."; GLAccountType := GenJournalLine."Bal. Account Type"; end else begin GLAccount := GenJournalLine."Account No."; GLAccountType := GenJournalLine."Account Type"; end; // Account types not G/L are not storing a GL account in the GenJnlLine's Account field, need to retrieve case GLAccountType of GenJournalLine."Account Type"::Customer: begin CustomerPostingGroup.Get(GenJournalLine."Posting Group"); Account := CustomerPostingGroup.GetReceivablesAccount(); end; GenJournalLine."Account Type"::Vendor: begin VendorPostingGroup.Get(GenJournalLine."Posting Group"); Account := VendorPostingGroup.GetPayablesAccount(); end; GenJournalLine."Account Type"::"Bank Account": begin BankAccount.Get(GLAccount); BankAccountPostingGroup.Get(BankAccount."Bank Acc. Posting Group"); Account := BankAccountPostingGroup."G/L Account No."; end; else Account := GLAccount; end; // Create the Posted Deferral Schedule with the Document Number created from the posted GL Trx... PostedDeferralHeader.Init(); PostedDeferralHeader.TransferFields(DeferralHeader); PostedDeferralHeader."Deferral Doc. Type" := DeferralHeader."Deferral Doc. Type"::"G/L"; // Adding document number so we can connect the Ledger and Deferral Schedule details... PostedDeferralHeader."Gen. Jnl. Document No." := GenJournalLine."Document No."; PostedDeferralHeader."Account No." := Account; PostedDeferralHeader."Document Type" := 0; PostedDeferralHeader."Document No." := ''; PostedDeferralHeader."Line No." := GenJournalLine."Line No."; PostedDeferralHeader."Currency Code" := GenJournalLine."Currency Code"; PostedDeferralHeader."Deferral Account" := DeferralAccount; PostedDeferralHeader."Posting Date" := GenJournalLine."Posting Date"; PostedDeferralHeader."Entry No." := FirstEntryNo; OnBeforePostedDeferralHeaderInsert(PostedDeferralHeader, GenJournalLine); PostedDeferralHeader.Insert(true); FilterDeferralLines( DeferralLine, DeferralHeader."Deferral Doc. Type"::"G/L".AsInteger(), GenJournalLine."Journal Template Name", GenJournalLine."Journal Batch Name", 0, '', GenJournalLine."Line No."); if DeferralLine.FindSet() then repeat PostedDeferralLine.Init(); PostedDeferralLine.TransferFields(DeferralLine); PostedDeferralLine."Deferral Doc. Type" := DeferralHeader."Deferral Doc. Type"::"G/L"; PostedDeferralLine."Gen. Jnl. Document No." := GenJournalLine."Document No."; PostedDeferralLine."Account No." := Account; PostedDeferralLine."Document Type" := 0; PostedDeferralLine."Document No." := ''; PostedDeferralLine."Line No." := GenJournalLine."Line No."; PostedDeferralLine."Currency Code" := GenJournalLine."Currency Code"; PostedDeferralLine."Deferral Account" := DeferralAccount; OnBeforePostedDeferralLineInsert(PostedDeferralLine, GenJournalLine); PostedDeferralLine.Insert(true); until DeferralLine.Next() = 0; end; OnAfterCreateScheduleFromGL(GenJournalLine, PostedDeferralHeader); GenJnlPostLine.RemoveDeferralSchedule(GenJournalLine); end; /// <summary> /// Validates and creates/updates a deferral schedule when a deferral code is entered or changed. /// Removes existing schedule if the code is cleared. /// </summary> /// <param name="DeferralCode">Deferral template code being validated</param> /// <param name="DeferralDocType">Type of document containing the deferral</param> /// <param name="GenJnlTemplateName">General Journal Template name for G/L deferrals</param> /// <param name="GenJnlBatchName">General Journal Batch name for G/L deferrals</param> /// <param name="DocumentType">Document type ID from the source document</param> /// <param name="DocumentNo">Document number from the source document</param> /// <param name="LineNo">Line number within the source document</param> /// <param name="Amount">Amount to defer</param> /// <param name="PostingDate">Posting date for the deferral</param> /// <param name="Description">Description for the deferral schedule</param> /// <param name="CurrencyCode">Currency code for foreign currency handling</param> procedure DeferralCodeOnValidate(DeferralCode: Code[10]; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer; Amount: Decimal; PostingDate: Date; Description: Text[100]; CurrencyCode: Code[10]) var DeferralHeader: Record "Deferral Header"; DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template"; IsHandled: Boolean; begin IsHandled := false; OnBeforeDeferralCodeOnValidate(DeferralCode, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo, Amount, PostingDate, Description, CurrencyCode, IsHandled); if IsHandled then exit; DeferralHeader.Init(); DeferralLine.Init(); if DeferralCode = '' then // If the user cleared the deferral code, we should remove the saved schedule... DeferralCodeOnDelete(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo) else if LineNo <> 0 then if DeferralTemplate.Get(DeferralCode) then begin ValidateDeferralTemplate(DeferralTemplate); CreateDeferralSchedule(DeferralCode, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo, Amount, DeferralTemplate."Calc. Method", PostingDate, DeferralTemplate."No. of Periods", true, GetDeferralDescription(GenJnlBatchName, DocumentNo, Description), true, CurrencyCode); end; end; /// <summary> /// Removes a deferral schedule when a deferral code is deleted or cleared. /// Deletes the header and all associated deferral lines. /// </summary> /// <param name="DeferralDocType">Type of document containing the deferral</param> /// <param name="GenJnlTemplateName">General Journal Template name for G/L deferrals</param> /// <param name="GenJnlBatchName">General Journal Batch name for G/L deferrals</param> /// <param name="DocumentType">Document type ID from the source document</param> /// <param name="DocumentNo">Document number from the source document</param> /// <param name="LineNo">Line number within the source document</param> procedure DeferralCodeOnDelete(DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer) var DeferralHeader: Record "Deferral Header"; begin if LineNo <> 0 then // Deferral Additions if DeferralHeader.Get(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo) then begin DeferralHeader.Delete(); RemoveDeferralLines(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo); end; end; /// <summary> /// Opens the deferral schedule editing page for a specific line. /// Creates a new schedule if one doesn't exist, or allows editing of an existing schedule. /// </summary> /// <param name="DeferralCode">Deferral template code</param> /// <param name="DeferralDocType">Type of document containing the deferral</param> /// <param name="GenJnlTemplateName">General Journal Template name for G/L deferrals</param> /// <param name="GenJnlBatchName">General Journal Batch name for G/L deferrals</param> /// <param name="DocumentType">Document type ID from the source document</param> /// <param name="DocumentNo">Document number from the source document</param> /// <param name="LineNo">Line number within the source document</param> /// <param name="Amount">Amount to defer</param> /// <param name="PostingDate">Posting date for the deferral</param> /// <param name="Description">Description for the deferral schedule</param> /// <param name="CurrencyCode">Currency code for foreign currency handling</param> /// <returns>True if changes were made to the schedule, false otherwise</returns> procedure OpenLineScheduleEdit(DeferralCode: Code[10]; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer; Amount: Decimal; PostingDate: Date; Description: Text[100]; CurrencyCode: Code[10]): Boolean var DeferralTemplate: Record "Deferral Template"; DeferralHeader: Record "Deferral Header"; DeferralSchedule: Page "Deferral Schedule"; Changed: Boolean; IsHandled: Boolean; begin OnBeforeOpenLineScheduleEdit(DeferralCode, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo, Amount, PostingDate, Description, CurrencyCode); if DeferralCode = '' then Message(SelectDeferralCodeMsg) else if DeferralTemplate.Get(DeferralCode) then if DeferralHeader.Get(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo) then begin IsHandled := false; OnOpenLineScheduleEditOnBeforeDeferralScheduleSetParameters(DeferralSchedule, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, DeferralHeader, IsHandled); if not IsHandled then DeferralSchedule.SetParameter(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo); DeferralSchedule.RunModal(); Changed := DeferralSchedule.GetParameter(); Clear(DeferralSchedule); end else begin CreateDeferralSchedule(DeferralCode, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo, Amount, DeferralTemplate."Calc. Method", PostingDate, DeferralTemplate."No. of Periods", true, GetDeferralDescription(GenJnlBatchName, DocumentNo, Description), true, CurrencyCode); Commit(); if DeferralHeader.Get(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo) then begin DeferralSchedule.SetParameter(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo); DeferralSchedule.RunModal(); Changed := DeferralSchedule.GetParameter(); Clear(DeferralSchedule); end; end; exit(Changed); end; /// <summary> /// Opens the deferral schedule view page for posted/archived deferrals in read-only mode. /// </summary> /// <param name="DeferralCode">Deferral template code</param> /// <param name="DeferralDocType">Type of document containing the deferral</param> /// <param name="GenJnlTemplateName">General Journal Template name for G/L deferrals</param> /// <param name="GenJnlBatchName">General Journal Batch name for G/L deferrals</param> /// <param name="DocumentType">Document type ID from the source document</param> /// <param name="DocumentNo">Document number from the source document</param> /// <param name="LineNo">Line number within the source document</param> procedure OpenLineScheduleView(DeferralCode: Code[10]; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer) var DeferralTemplate: Record "Deferral Template"; PostedDeferralHeader: Record "Posted Deferral Header"; begin // On view nothing will happen if the record does not exist if DeferralCode <> '' then if DeferralTemplate.Get(DeferralCode) then if PostedDeferralHeader.Get(DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo) then PAGE.RunModal(PAGE::"Deferral Schedule View", PostedDeferralHeader); end; /// <summary> /// Opens the archived deferral schedule view page for document archive scenarios. /// </summary> /// <param name="DeferralCode">Deferral template code</param> /// <param name="DeferralDocType">Type of document containing the deferral</param> /// <param name="DocumentType">Document type ID from the source document</param> /// <param name="DocumentNo">Document number from the source document</param> /// <param name="DocNoOccurence">Document number occurrence for archive</param> /// <param name="VersionNo">Version number for archive</param> /// <param name="LineNo">Line number within the source document</param> procedure OpenLineScheduleArchive(DeferralCode: Code[10]; DeferralDocType: Integer; DocumentType: Integer; DocumentNo: Code[20]; DocNoOccurence: Integer; VersionNo: Integer; LineNo: Integer) var DeferralHeaderArchive: Record "Deferral Header Archive"; begin // On view nothing will happen if the record does not exist if DeferralCode <> '' then if DeferralHeaderArchive.Get(DeferralDocType, DocumentType, DocumentNo, DocNoOccurence, VersionNo, LineNo) then PAGE.RunModal(PAGE::"Deferral Schedule Archive", DeferralHeaderArchive); end; local procedure RemoveDeferralLines(DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer) var DeferralLine: Record "Deferral Line"; begin FilterDeferralLines(DeferralLine, DeferralDocType, GenJnlTemplateName, GenJnlBatchName, DocumentType, DocumentNo, LineNo); DeferralLine.DeleteAll(); end; local procedure ValidateDeferralTemplate(DeferralTemplate: Record "Deferral Template") var IsHandled: Boolean; begin IsHandled := false; OnBeforeValidateDeferralTemplate(DeferralTemplate, IsHandled); if IsHandled then exit; DeferralTemplate.TestField("Deferral Account"); DeferralTemplate.TestField("Deferral %"); DeferralTemplate.TestField("No. of Periods"); end; /// <summary> /// Rounds deferral amounts to appropriate precision based on currency settings. /// Handles both LCY and foreign currency amounts with proper rounding. /// </summary> /// <param name="DeferralHeader">Deferral header containing schedule information</param> /// <param name="CurrencyCode">Currency code for the amounts</param> /// <param name="CurrencyFactor">Exchange rate factor for currency conversion</param> /// <param name="PostingDate">Date for currency exchange rate lookup</param> /// <param name="AmtToDefer">Amount to defer (will be updated with rounded value)</param> /// <param name="AmtToDeferLCY">LCY amount to defer (will be updated with rounded value)</param> procedure RoundDeferralAmount(var DeferralHeader: Record "Deferral Header"; CurrencyCode: Code[10]; CurrencyFactor: Decimal; PostingDate: Date; var AmtToDefer: Decimal; var AmtToDeferLCY: Decimal) var DeferralLine: Record "Deferral Line"; CurrencyExchangeRate: Record "Currency Exchange Rate"; UseDate: Date; DeferralCount: Integer; TotalAmountLCY: Decimal; TotalDeferralCount: Integer; IsHandled: Boolean; begin IsHandled := false; OnBeforeRoundDeferralAmount(DeferralHeader, CurrencyCode, CurrencyFactor, PostingDate, IsHandled); if IsHandled then exit; // Calculate the LCY amounts for posting if PostingDate = 0D then UseDate := WorkDate() else UseDate := PostingDate; DeferralHeader."Amount to Defer (LCY)" := Round(CurrencyExchangeRate.ExchangeAmtFCYToLCY(UseDate, CurrencyCode, DeferralHeader."Amount to Defer", CurrencyFactor)); DeferralHeader.Modify(); AmtToDefer := DeferralHeader."Amount to Defer"; AmtToDeferLCY := DeferralHeader."Amount to Defer (LCY)"; TotalAmountLCY := 0; FilterDeferralLines( DeferralLine, DeferralHeader."Deferral Doc. Type".AsInteger(), DeferralHeader."Gen. Jnl. Template Name", DeferralHeader."Gen. Jnl. Batch Name", DeferralHeader."Document Type", DeferralHeader."Document No.", DeferralHeader."Line No."); if DeferralLine.FindSet() then begin TotalDeferralCount := DeferralLine.Count(); repeat DeferralCount := DeferralCount + 1; if DeferralCount = TotalDeferralCount then begin DeferralLine."Amount (LCY)" := DeferralHeader."Amount to Defer (LCY)" - TotalAmountLCY; DeferralLine.Modify(); end else begin DeferralLine."Amount (LCY)" := Round(CurrencyExchangeRate.ExchangeAmtFCYToLCY(UseDate, CurrencyCode, DeferralLine.Amount, CurrencyFactor)); TotalAmountLCY := TotalAmountLCY + DeferralLine."Amount (LCY)"; DeferralLine.Modify(); end; until DeferralLine.Next() = 0; end; end; local procedure InitCurrency(CurrencyCode: Code[10]) var Currency: Record Currency; begin if CurrencyCode = '' then Currency.InitRoundingPrecision() else begin Currency.Get(CurrencyCode); Currency.TestField("Amount Rounding Precision"); end; AmountRoundingPrecision := Currency."Amount Rounding Precision"; end; /// <summary> /// Initializes a deferral line record with header information and sets the appropriate posting date. /// Handles period-based date calculations using accounting periods. /// </summary> /// <param name="DeferralLine">Deferral line record to initialize</param> /// <param name="DeferralHeader">Deferral header containing source information</param> /// <param name="PeriodicCount">Current period number in the deferral schedule</param> /// <param name="PostDate">Posting date that will be updated based on period calculations</param> procedure InitializeDeferralHeaderAndSetPostDate(var DeferralLine: Record "Deferral Line"; DeferralHeader: Record "Deferral Header"; PeriodicCount: Integer; var PostDate: Date) var AccountingPeriod: Record "Accounting Period"; begin DeferralLine.Init(); DeferralLine."Deferral Doc. Type" := DeferralHeader."Deferral Doc. Type"; DeferralLine."Gen. Jnl. Template Name" := DeferralHeader."Gen. Jnl. Template Name"; DeferralLine."Gen. Jnl. Batch Name" := DeferralHeader."Gen. Jnl. Batch Name"; DeferralLine."Document Type" := DeferralHeader."Document Type"; DeferralLine."Document No." := DeferralHeader."Document No."; DeferralLine."Line No." := DeferralHeader."Line No."; DeferralLine."Currency Code" := DeferralHeader."Currency Code"; OnInitializeDeferralHeaderAndSetPostDateAfterInitDeferralLine(DeferralLine); if PeriodicCount = 1 then begin if not AccountingPeriod.IsEmpty() then begin AccountingPeriod.SetFilter("Starting Date", '..%1', DeferralHeader."Start Date"); if not AccountingPeriod.FindFirst() then Error(DeferSchedOutOfBoundsErr); end; PostDate := DeferralHeader."Start Date"; end else begin if IsAccountingPeriodExist(AccountingPeriod, CalcDate('<CM>', PostDate) + 1) then begin AccountingPeriod.SetFilter("Starting Date", '>%1', PostDate); if not AccountingPeriod.FindFirst() then Error(DeferSchedOutOfBoundsErr); end; PostDate := AccountingPeriod."Starting Date"; end; OnAfterInitializeDeferralHeaderAndSetPostDate(DeferralLine, DeferralHeader, PeriodicCount, PostDate); end; local procedure IsAccountingPeriodExist(var AccountingPeriod: Record "Accounting Period"; PostingDate: Date): Boolean var AccountingPeriodMgt: Codeunit "Accounting Period Mgt."; begin AccountingPeriod.Reset(); if not AccountingPeriod.IsEmpty() then exit(true); AccountingPeriodMgt.InitDefaultAccountingPeriod(AccountingPeriod, PostingDate); exit(false); end; /// <summary> /// Gets the start date for a deferral from existing schedule or calculates from template settings. /// Used to maintain consistency when adjusting existing deferrals. /// </summary> /// <param name="DeferralDocType">Type of document containing the deferral</param> /// <param name="RecordDocumentType">Document type ID from the source document</param> /// <param name="RecordDocumentNo">Document number from the source document</param> /// <param name="RecordLineNo">Line number within the source document</param> /// <param name="DeferralCode">Deferral template code</param> /// <param name="PostingDate">Default posting date if no template or schedule exists</param> /// <returns>Start date for the deferral schedule</returns> procedure GetDeferralStartDate(DeferralDocType: Integer; RecordDocumentType: Integer; RecordDocumentNo: Code[20]; RecordLineNo: Integer; DeferralCode: Code[10]; PostingDate: Date): Date var DeferralHeader: Record "Deferral Header"; DeferralTemplate: Record "Deferral Template"; begin if DeferralHeader.Get(DeferralDocType, '', '', RecordDocumentType, RecordDocumentNo, RecordLineNo) then exit(DeferralHeader."Start Date"); if DeferralTemplate.Get(DeferralCode) then exit(SetStartDate(DeferralTemplate, PostingDate)); exit(PostingDate); end; /// <summary> /// Adjusts total amounts for deferral posting by subtracting deferred amounts from totals. /// Handles both LCY and ACY amounts with VAT base calculations. /// </summary> /// <param name="DeferralCode">Deferral template code, blank if no deferral</param> /// <param name="AmtToDefer">Amount being deferred (may be zeroed if fully deferred)</param> /// <param name="AmtToDeferACY">ACY amount being deferred</param> /// <param name="TotalAmount">Total amount to adjust</param> /// <param name="TotalAmountACY">Total ACY amount to adjust</param> /// <param name="TotalVATBase">VAT base amount to set</param> /// <param name="TotalVATBaseACY">ACY VAT base amount to set</param> procedure AdjustTotalAmountForDeferrals(DeferralCode: Code[10]; var AmtToDefer: Decimal; var AmtToDeferACY: Decimal; var TotalAmount: Decimal; var TotalAmountACY: Decimal; var TotalVATBase: Decimal; var TotalVATBaseACY: Decimal) begin AdjustTotalAmountForDeferrals(DeferralCode, AmtToDefer, AmtToDeferACY, TotalAmount, TotalAmountACY, TotalVATBase, TotalVATBaseACY, 0, 0); end; /// <summary> /// Adjusts total amounts for deferral posting including discount handling. /// Extended version with discount amount parameters. /// </summary> /// <param name="DeferralCode">Deferral template code, blank if no deferral</param> /// <param name="AmtToDefer">Amount being deferred (may be zeroed if fully deferred)</param> /// <param name="AmtToDeferACY">ACY amount being deferred</param> /// <param name="TotalAmount">Total amount to adjust</param> /// <param name="TotalAmountACY">Total ACY amount to adjust</param> /// <param name="TotalVATBase">VAT base amount to set</param> /// <param name="TotalVATBaseACY">ACY VAT base amount to set</param> /// <param name="DiscountAmount">Discount amount to consider</param> /// <param name="DiscountAmountACY">ACY discount amount to consider</param> procedure AdjustTotalAmountForDeferrals(DeferralCode: Code[10]; var AmtToDefer: Decimal; var AmtToDeferACY: Decimal; var TotalAmount: Decimal; var TotalAmountACY: Decimal; var TotalVATBase: Decimal; var TotalVATBaseACY: Decimal; DiscountAmount: Decimal; DiscountAmountACY: Decimal) begin TotalVATBase := TotalAmount; TotalVATBaseACY := TotalAmountACY; if DeferralCode <> '' then if (AmtToDefer = TotalAmount - DiscountAmount) and (AmtToDeferACY = TotalAmountACY - DiscountAmountACY) then begin AmtToDefer := 0; AmtToDeferACY := 0; end else begin TotalAmount := TotalAmount - AmtToDefer; TotalAmountACY := TotalAmountACY - AmtToDeferACY; end; OnAfterAdjustTotalAmountForDeferrals(DeferralCode, AmtToDefer, AmtToDeferACY, TotalAmount, TotalAmountACY, DiscountAmount, DiscountAmountACY); end; /// <summary> /// Adjusts total amounts for deferral posting without VAT base calculations. /// Simplified version for scenarios where VAT base is not required. /// </summary> /// <param name="DeferralCode">Deferral template code, blank if no deferral</param> /// <param name="AmtToDefer">Amount being deferred (may be zeroed if fully deferred)</param> /// <param name="AmtToDeferACY">ACY amount being deferred</param> /// <param name="TotalAmount">Total amount to adjust</param> /// <param name="TotalAmountACY">Total ACY amount to adjust</param> procedure AdjustTotalAmountForDeferralsNoBase(DeferralCode: Code[10]; var AmtToDefer: Decimal; var AmtToDeferACY: Decimal; var TotalAmount: Decimal; var TotalAmountACY: Decimal) begin AdjustTotalAmountForDeferralsNoBase(DeferralCode, AmtToDefer, AmtToDeferACY, TotalAmount, TotalAmountACY, 0, 0); end; /// <summary> /// Adjusts total amounts for deferral posting without VAT base calculations, including discount handling. /// Extended version with discount amount parameters. /// </summary> /// <param name="DeferralCode">Deferral template code, blank if no deferral</param> /// <param name="AmtToDefer">Amount being deferred (may be zeroed if fully deferred)</param> /// <param name="AmtToDeferACY">ACY amount being deferred</param> /// <param name="TotalAmount">Total amount to adjust</param> /// <param name="TotalAmountACY">Total ACY amount to adjust</param> /// <param name="DiscountAmount">Discount amount to consider</param> /// <param name="DiscountAmountACY">ACY discount amount to consider</param> procedure AdjustTotalAmountForDeferralsNoBase(DeferralCode: Code[10]; var AmtToDefer: Decimal; var AmtToDeferACY: Decimal; var TotalAmount: Decimal; var TotalAmountACY: Decimal; DiscountAmount: Decimal; DiscountAmountACY: Decimal) begin if DeferralCode <> '' then if (AmtToDefer = TotalAmount - DiscountAmount) and (AmtToDeferACY = TotalAmountACY - DiscountAmountACY) then begin AmtToDefer := 0; AmtToDeferACY := 0; end else begin TotalAmount := TotalAmount - AmtToDefer; TotalAmountACY := TotalAmountACY - AmtToDeferACY; end; OnAfterAdjustTotalAmountForDeferrals(DeferralCode, AmtToDefer, AmtToDeferACY, TotalAmount, TotalAmountACY, DiscountAmount, DiscountAmountACY); end; /// <summary> /// Validates general journal line conditions for deferral usage. /// Ensures source codes are properly configured for deferral processing. /// </summary> /// <param name="GenJournalLine">General journal line to validate</param> procedure CheckDeferralConditionForGenJournal(var GenJournalLine: Record "Gen. Journal Line") var SourceCodeSetup: Record "Source Code Setup"; GenJournalTemplate: Record "Gen. Journal Template"; RequiredSourceCode: Code[10]; ErrorInfo: ErrorInfo; SameSourceCodeErr: Label 'Journal Source Code %1 is same as Source Code set for Purchase/Sales documents. This is not allowed when using deferrals. If you want to use this journal for deferrals, please update Source Codes on Gen Journal Template and generate line again.', Comment = '%1->Source Code'; RequiredSourceCodeErr: Label 'Journal Source Code %1 is not same as default Source Code set for Gen. Journal Template with type %2. Deferrals can only be used when the journal line has the same source code as the source code defined for the journal in source code Setup. Please update this Gen. Journal Template or change the setup in Source Code Setup.', Comment = '%1->Source Code, %2->Gen. Journal Template Type'; OpenSourceCodeSetupTxt: Label 'Open Source Code Setup'; OpenSourceCodeSetupDescTxt: Label 'Open Source Code Setup page to check Source code setup.'; OpenGenJournalTemplateTxt: Label 'Open Gen. Journal Template'; OpenGenJournalTemplateDescTxt: Label 'Open Gen. Journal Template page to update Source code.'; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckDeferralConditionForGenJournal(GenJournalLine, IsHandled); if IsHandled then exit; if GenJournalLine."Deferral Code" = '' then exit; SourceCodeSetup.Get(); if GenJournalLine."Source Code" in [SourceCodeSetup.Sales, SourceCodeSetup.Purchases] then begin ErrorInfo.ErrorType(ErrorType::Client); ErrorInfo.Verbosity(Verbosity::Error); ErrorInfo.Message(StrSubstNo(SameSourceCodeErr, GenJournalLine."Source Code")); ErrorInfo.TableId(GenJournalLine.RecordId.TableNo); ErrorInfo.RecordId(GenJournalLine.RecordId); ErrorInfo.AddAction(OpenGenJournalTemplateTxt, Codeunit::"Deferral Utilities", 'ShowGenJournalTemplate', OpenGenJournalTemplateDescTxt); ErrorInfo.AddAction(OpenSourceCodeSetupTxt, Codeunit::"Deferral Utilities", 'ShowSourceCodeSetup', OpenSourceCodeSetupDescTxt); Error(ErrorInfo); end; GenJournalTemplate.Get(GenJournalLine."Journal Template Name"); case GenJournalTemplate.Type of GenJournalTemplate.Type::General: RequiredSourceCode := SourceCodeSetup."General Journal"; GenJournalTemplate.Type::Purchases: RequiredSourceCode := SourceCodeSetup."Purchase Journal"; GenJournalTemplate.Type::Sales: RequiredSourceCode := SourceCodeSetup."Sales Journal"; end; if GenJournalLine."Source Code" <> RequiredSourceCode then begin ErrorInfo.ErrorType(ErrorType::Client); ErrorInfo.Verbosity(Verbosity::Error); ErrorInfo.Message(StrSubstNo(RequiredSourceCodeErr, GenJournalLine."Source Code", GenJournalTemplate.Type)); ErrorInfo.TableId(GenJournalLine.RecordId.TableNo); ErrorInfo.RecordId(GenJournalLine.RecordId); ErrorInfo.AddAction(OpenGenJournalTemplateTxt, Codeunit::"Deferral Utilities", 'ShowGenJournalTemplate', OpenGenJournalTemplateDescTxt); ErrorInfo.AddAction(OpenSourceCodeSetupTxt, Codeunit::"Deferral Utilities", 'ShowSourceCodeSetup', OpenSourceCodeSetupDescTxt); Error(ErrorInfo); end; end; /// <summary> /// Opens the General Journal Templates page filtered to the template from the error context. /// Action method for error handling in deferral validation. /// </summary> /// <param name="ErrorInfo">Error information containing the journal line context</param> procedure ShowGenJournalTemplate(ErrorInfo: ErrorInfo) var GenJournalTemplate: Record "Gen. Journal Template"; GenJournalLine: Record "Gen. Journal Line"; GeneralJournalTemplates: Page "General Journal Templates"; RecordRef: RecordRef; begin RecordRef := ErrorInfo.RecordId.GetRecord(); RecordRef.SetTable(GenJournalLine); GenJournalTemplate.SetRange(Name, GenJournalLine."Journal Template Name"); GeneralJournalTemplates.SetTableView(GenJournalTemplate); GeneralJournalTemplates.RunModal(); end; /// <summary> /// Opens the Source Code Setup page for configuring source codes. /// Action method for error handling in deferral validation. /// </summary> /// <param name="ErrorInfo">Error information for context</param> procedure ShowSourceCodeSetup(ErrorInfo: ErrorInfo) var SourceCodeSetup: Page "Source Code Setup"; begin SourceCodeSetup.RunModal(); end; local procedure GetPeriodStartingDate(PostingDate: Date) Result: Date var AccountingPeriod: Record "Accounting Period"; PeriodStartingDateHandled: Boolean; begin PeriodStartingDateHandled := false; OnBeforeGetPeriodStartingDate(PostingDate, Result, PeriodStartingDateHandled); if PeriodStartingDateHandled then exit(Result); if AccountingPeriod.IsEmpty() then exit(CalcDate('<-CM>', PostingDate)); AccountingPeriod.SetFilter("Starting Date", '<%1', PostingDate); if AccountingPeriod.FindLast() then exit(AccountingPeriod."Starting Date"); Error(DeferSchedOutOfBoundsErr); end; local procedure GetNextPeriodStartingDate(PostingDate: Date): Date var AccountingPeriod: Record "Accounting Period"; begin if AccountingPeriod.IsEmpty() then exit(CalcDate('<CM+1D>', PostingDate)); AccountingPeriod.SetFilter("Starting Date", '>%1', PostingDate); if AccountingPeriod.FindFirst() then exit(AccountingPeriod."Starting Date"); Error(DeferSchedOutOfBoundsErr); end; local procedure GetCurPeriodStartingDate(PostingDate: Date): Date var AccountingPeriod: Record "Accounting Period"; begin if AccountingPeriod.IsEmpty() then exit(CalcDate('<-CM>', PostingDate)); AccountingPeriod.SetFilter("Starting Date", '<=%1', PostingDate); AccountingPeriod.FindLast(); exit(AccountingPeriod."Starting Date"); end; local procedure GetDeferralDescription(GenJnlBatchName: Code[10]; DocumentNo: Code[20]; Description: Text[100]) Result: Text[100] var IsHandled: Boolean; begin IsHandled := false; OnBeforeGetDeferralDescription(GenJnlBatchName, DocumentNo, Description, Result, IsHandled); if IsHandled then exit(Result); if GenJnlBatchName <> '' then exit(CopyStr(StrSubstNo(DescriptionTok, GenJnlBatchName, Description), 1, 100)); exit(CopyStr(StrSubstNo(DescriptionTok, DocumentNo, Description), 1, 100)); end; /// <summary> /// Creates a copy of an existing deferral schedule for a new source line. /// Used when copying document lines to maintain consistent deferral schedules. /// </summary> /// <param name="DeferralHeader">Source deferral header to copy from</param> /// <param name="NewSourceLineNo">New line number for the copied schedule</param> procedure CreateCopyOfDeferralSchedule(DeferralHeader: Record "Deferral Header"; NewSourceLineNo: Integer) var DeferralLine: Record "Deferral Line"; NewDeferralHeader: Record "Deferral Header"; NewDeferralLine: Record "Deferral Line"; begin if NewDeferralHeader.Get( DeferralHeader."Deferral Doc. Type", DeferralHeader."Gen. Jnl. Template Name", DeferralHeader."Gen. Jnl. Batch Name", DeferralHeader."Document Type", DeferralHeader."Document No.", NewSourceLineNo) then exit; NewDeferralHeader.TransferFields(DeferralHeader); NewDeferralHeader."Line No." := NewSourceLineNo; NewDeferralHeader.Insert(); FilterDeferralLines(NewDeferralLine, NewDeferralHeader."Deferral Doc. Type".AsInteger(), NewDeferralHeader."Gen. Jnl. Template Name", NewDeferralHeader."Gen. Jnl. Batch Name", NewDeferralHeader."Document Type", NewDeferralHeader."Document No.", NewDeferralHeader."Line No."); if not NewDeferralLine.IsEmpty() then exit; FilterDeferralLines(DeferralLine, DeferralHeader."Deferral Doc. Type".AsInteger(), DeferralHeader."Gen. Jnl. Template Name", DeferralHeader."Gen. Jnl. Batch Name", DeferralHeader."Document Type", DeferralHeader."Document No.", DeferralHeader."Line No."); if DeferralLine.FindSet() then repeat NewDeferralLine.TransferFields(DeferralLine); NewDeferralLine."Line No." := NewDeferralHeader."Line No."; NewDeferralLine.Insert(); until DeferralLine.Next() = 0; end; /// <summary> /// Integration event raised after calculating deferral amounts using days per period method. /// Enables custom processing or adjustments to deferral calculations. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="DeferralLine">Deferral line record with calculated amounts</param> /// <param name="DeferralTemplate">Deferral template containing calculation settings</param> /// <remarks> /// Raised from CalculateDaysPerPeriod procedure after completing days-based deferral calculations. /// </remarks> [IntegrationEvent(false, false)] local procedure OnAfterCalculateDaysPerPeriod(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") begin end; /// <summary> /// Integration event raised after calculating deferral amounts using equal per period method. /// Enables custom processing or adjustments to equal period deferral calculations. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="DeferralLine">Deferral line record with calculated amounts</param> /// <param name="DeferralTemplate">Deferral template containing calculation settings</param> /// <remarks> /// Raised from CalculateEqualPerPeriod procedure after completing equal period deferral calculations. /// </remarks> [IntegrationEvent(false, false)] local procedure OnAfterCalculateEqualPerPeriod(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") begin end; /// <summary> /// Integration event raised after calculating deferral amounts using straight-line method. /// Enables custom processing or adjustments to straight-line deferral calculations. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="DeferralLine">Deferral line record with calculated amounts</param> /// <param name="DeferralTemplate">Deferral template containing calculation settings</param> /// <remarks> /// Raised from CalculateStraightline procedure after completing straight-line deferral calculations. /// </remarks> [IntegrationEvent(false, false)] local procedure OnAfterCalculateStraightline(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") begin end; /// <summary> /// Integration event raised after calculating deferral amounts using user-defined method. /// Enables custom processing or adjustments to user-defined deferral calculations. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="DeferralLine">Deferral line record with calculated amounts</param> /// <param name="DeferralTemplate">Deferral template containing calculation settings</param> /// <remarks> /// Raised from CalculateUserDefined procedure after completing user-defined deferral calculations. /// </remarks> [IntegrationEvent(false, false)] local procedure OnAfterCalculateUserDefined(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") begin end; /// <summary> /// Integration event raised after creating the complete deferral schedule. /// Enables custom processing or validation after schedule generation is complete. /// </summary> /// <param name="DeferralHeader">Deferral header record for the created schedule</param> /// <param name="DeferralLine">Deferral line record representing the schedule lines</param> /// <param name="DeferralTemplate">Deferral template used for schedule creation</param> /// <param name="CalcMethod">Calculation method used for the schedule</param> /// <remarks> /// Raised from CreateDeferralSchedule procedure after completing schedule creation. /// </remarks> [IntegrationEvent(false, false)] local procedure OnAfterCreateDeferralSchedule(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template"; CalcMethod: Enum "Deferral Calculation Method") begin end; /// <summary> /// Integration event raised after creating deferral schedule from general journal line posting. /// Enables custom processing or field updates after G/L deferral schedule creation. /// </summary> /// <param name="GenJournalLine">General journal line that was posted</param> /// <param name="PostedDeferralHeader">Posted deferral header created from the journal line</param> /// <remarks> /// Raised from CreateScheduleFromGL procedure after creating posted deferral records. /// </remarks> [IntegrationEvent(false, false)] local procedure OnAfterCreateScheduleFromGL(var GenJournalLine: Record "Gen. Journal Line"; var PostedDeferralHeader: Record "Posted Deferral Header") begin end; /// <summary> /// Integration event raised after setting the start date for deferral calculations. /// Enables custom start date logic or adjustments based on deferral template settings. /// </summary> /// <param name="DeferralTemplate">Deferral template containing start date calculation rules</param> /// <param name="StartDate">Original start date for the deferral</param> /// <param name="AdjustedStartDate">Adjusted start date for calculations (can be modified by subscribers)</param> /// <remarks> /// Raised from SetStartDate procedure after calculating adjusted start date. /// </remarks> [IntegrationEvent(false, false)] local procedure OnAfterSetStartDate(DeferralTemplate: Record "Deferral Template"; var StartDate: Date; var AdjustedStartDate: Date) begin end; /// <summary> /// Integration event raised before calculating deferral amounts using days per period method. /// Enables custom preprocessing or parameter modification before days-based calculations. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="DeferralLine">Deferral line record to be calculated</param> /// <param name="DeferralTemplate">Deferral template containing calculation settings</param> /// <remarks> /// Raised from CalculateDaysPerPeriod procedure before starting days-based deferral calculations. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeCalculateDaysPerPeriod(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") begin end; /// <summary> /// Integration event raised before calculating deferral amounts using equal per period method. /// Enables custom preprocessing or parameter modification before equal period calculations. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="DeferralLine">Deferral line record to be calculated</param> /// <param name="DeferralTemplate">Deferral template containing calculation settings</param> /// <remarks> /// Raised from CalculateEqualPerPeriod procedure before starting equal period deferral calculations. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeCalculateEqualPerPeriod(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") begin end; /// <summary> /// Integration event raised before calculating deferral amounts using straight-line method. /// Enables custom preprocessing or parameter modification before straight-line calculations. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="DeferralLine">Deferral line record to be calculated</param> /// <param name="DeferralTemplate">Deferral template containing calculation settings</param> /// <remarks> /// Raised from CalculateStraightline procedure before starting straight-line deferral calculations. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeCalculateStraightline(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") begin end; /// <summary> /// Integration event raised before calculating deferral amounts using user-defined method. /// Enables custom preprocessing or parameter modification before user-defined calculations. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="DeferralLine">Deferral line record to be calculated</param> /// <param name="DeferralTemplate">Deferral template containing calculation settings</param> /// <remarks> /// Raised from CalculateUserDefined procedure before starting user-defined deferral calculations. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeCalculateUserDefined(DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") begin end; /// <summary> /// Integration event raised before creating a deferral schedule with comprehensive parameters. /// Enables custom schedule creation logic or parameter validation before schedule generation. /// </summary> /// <param name="DeferralCode">Deferral template code for the schedule</param> /// <param name="DeferralDocType">Document type for the deferral (G/L, Sales, Purchase)</param> /// <param name="GenJnlTemplateName">General journal template name if applicable</param> /// <param name="GenJnlBatchName">General journal batch name if applicable</param> /// <param name="DocumentType">Document type identifier</param> /// <param name="DocumentNo">Document number for the deferral</param> /// <param name="LineNo">Line number within the document</param> /// <param name="AmountToDefer">Total amount to be deferred</param> /// <param name="CalcMethod">Calculation method for the schedule</param> /// <param name="StartDate">Start date for the deferral schedule</param> /// <param name="NoOfPeriods">Number of periods for the deferral</param> /// <param name="ApplyDeferralPercentage">Whether to apply percentage-based deferrals</param> /// <param name="DeferralDescription">Description for the deferral schedule</param> /// <param name="AdjustStartDate">Whether to adjust the start date</param> /// <param name="CurrencyCode">Currency code for the deferral</param> /// <param name="IsHandled">Set to true to skip standard schedule creation</param> /// <param name="RedistributeDeferralSchedule">Whether to redistribute the schedule</param> /// <remarks> /// Raised from CreateDeferralSchedule procedure before creating deferral header and lines. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeCreateDeferralSchedule(DeferralCode: Code[10]; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer; AmountToDefer: Decimal; CalcMethod: Enum "Deferral Calculation Method"; var StartDate: Date; var NoOfPeriods: Integer; ApplyDeferralPercentage: Boolean; DeferralDescription: Text[100]; var AdjustStartDate: Boolean; CurrencyCode: Code[10]; var IsHandled: Boolean; var RedistributeDeferralSchedule: Boolean) begin end; /// <summary> /// Integration event raised before validating deferral code input. /// Enables custom deferral code validation logic or preprocessing. /// </summary> /// <param name="DeferralCode">Deferral template code being validated</param> /// <param name="DeferralDocType">Document type for the deferral</param> /// <param name="GenJnlTemplateName">General journal template name if applicable</param> /// <param name="GenJnlBatchName">General journal batch name if applicable</param> /// <param name="DocumentType">Document type identifier</param> /// <param name="DocumentNo">Document number for the deferral</param> /// <param name="LineNo">Line number within the document</param> /// <param name="Amount">Deferral amount</param> /// <param name="PostingDate">Posting date for the deferral</param> /// <param name="Description">Description for the deferral</param> /// <param name="CurrencyCode">Currency code for the deferral</param> /// <param name="IsHandled">Set to true to skip standard deferral code validation</param> /// <remarks> /// Raised from DeferralCodeOnValidate procedure before standard deferral code processing. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeDeferralCodeOnValidate(DeferralCode: Code[10]; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer; Amount: Decimal; PostingDate: Date; Description: Text[100]; CurrencyCode: Code[10]; var IsHandled: Boolean) begin end; /// <summary> /// Integration event raised before inserting posted deferral header record. /// Enables custom field updates or validation before posted deferral header creation. /// </summary> /// <param name="PostedDeferralHeader">Posted deferral header record to be inserted</param> /// <param name="GenJournalLine">Source general journal line for the deferral</param> /// <remarks> /// Raised from CreateScheduleFromGL procedure before inserting posted deferral header. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforePostedDeferralHeaderInsert(var PostedDeferralHeader: Record "Posted Deferral Header"; GenJournalLine: Record "Gen. Journal Line") begin end; /// <summary> /// Integration event raised before inserting posted deferral line record. /// Enables custom field updates or validation before posted deferral line creation. /// </summary> /// <param name="PostedDeferralLine">Posted deferral line record to be inserted</param> /// <param name="GenJournalLine">Source general journal line for the deferral</param> /// <remarks> /// Raised from CreateScheduleFromGL procedure before inserting posted deferral lines. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforePostedDeferralLineInsert(var PostedDeferralLine: Record "Posted Deferral Line"; GenJournalLine: Record "Gen. Journal Line") begin end; /// <summary> /// Integration event raised before opening deferral schedule editor for line editing. /// Enables custom preprocessing or parameter modification before schedule editing. /// </summary> /// <param name="DeferralCode">Deferral template code for the schedule</param> /// <param name="DeferralDocType">Document type for the deferral</param> /// <param name="GenJnlTemplateName">General journal template name if applicable</param> /// <param name="GenJnlBatchName">General journal batch name if applicable</param> /// <param name="DocumentType">Document type identifier</param> /// <param name="DocumentNo">Document number for the deferral</param> /// <param name="LineNo">Line number within the document</param> /// <param name="Amount">Deferral amount</param> /// <param name="PostingDate">Posting date for the deferral</param> /// <param name="Description">Description for the deferral</param> /// <param name="CurrencyCode">Currency code for the deferral</param> /// <remarks> /// Raised from OpenLineScheduleEdit procedure before opening deferral schedule page. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeOpenLineScheduleEdit(DeferralCode: Code[10]; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer; Amount: Decimal; PostingDate: Date; Description: Text[100]; CurrencyCode: Code[10]) begin end; /// <summary> /// Integration event raised after adjusting total amounts for deferral calculations. /// Enables custom processing or validation after deferral amount adjustments. /// </summary> /// <param name="DeferralCode">Deferral template code</param> /// <param name="AmtToDefer">Amount to defer in local currency</param> /// <param name="AmtToDeferACY">Amount to defer in additional currency</param> /// <param name="TotalAmount">Total amount in local currency</param> /// <param name="TotalAmountACY">Total amount in additional currency</param> /// <param name="DiscountAmount">Discount amount in local currency</param> /// <param name="DiscountAmountACY">Discount amount in additional currency</param> /// <remarks> /// Raised from AdjustTotalAmountForDeferrals procedure after calculating adjusted amounts. /// </remarks> [IntegrationEvent(false, false)] local procedure OnAfterAdjustTotalAmountForDeferrals(DeferralCode: Code[10]; var AmtToDefer: Decimal; var AmtToDeferACY: Decimal; var TotalAmount: Decimal; var TotalAmountACY: Decimal; DiscountAmount: Decimal; DiscountAmountACY: Decimal); begin end; /// <summary> /// Integration event raised before calculating number of deferral periods. /// Enables custom period calculation logic based on calculation method and start date. /// </summary> /// <param name="CalcMethod">Calculation method for determining periods</param> /// <param name="NoOfPeriods">Number of periods (can be modified by subscribers)</param> /// <param name="StartDate">Start date for period calculation</param> /// <param name="IsHandled">Set to true to skip standard period calculation</param> /// <remarks> /// Raised from CalcDeferralNoOfPeriods procedure before standard period calculation. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeCalcDeferralNoOfPeriods(CalcMethod: Enum "Deferral Calculation Method"; var NoOfPeriods: Integer; StartDate: Date; var IsHandled: Boolean) begin end; /// <summary> /// Integration event raised before checking posting date validity for deferral lines. /// Enables custom posting date validation logic for deferral schedules. /// </summary> /// <param name="DeferralHeader">Deferral header context for validation</param> /// <param name="DeferralLine">Deferral line with posting date to validate</param> /// <param name="IsHandled">Set to true to skip standard posting date validation</param> /// <remarks> /// Raised from CheckPostingDate procedure before standard date validation logic. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeCheckPostingDate(DeferralHeader: Record "Deferral Header"; var DeferralLine: record "Deferral Line"; var IsHandled: Boolean) begin end; /// <summary> /// Integration event raised before generating deferral description text. /// Enables custom description logic for deferral schedule entries. /// </summary> /// <param name="GenJnlBatchName">General journal batch name for context</param> /// <param name="DocumentNo">Document number for the deferral</param> /// <param name="Description">Source description text</param> /// <param name="Result">Generated description result (can be modified by subscribers)</param> /// <param name="IsHandled">Set to true to skip standard description generation</param> /// <remarks> /// Raised from GetDeferralDescription procedure before standard description generation. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeGetDeferralDescription(GenJnlBatchName: Code[10]; DocumentNo: Code[20]; Description: Text[100]; var Result: Text[100]; var IsHandled: Boolean) begin end; /// <summary> /// Integration event raised before inserting deferral line during equal per period calculation. /// Enables custom field updates or validation before line insertion. /// </summary> /// <param name="DeferralHeader">Deferral header context for the calculation</param> /// <param name="DeferralLine">Deferral line record to be inserted</param> /// <remarks> /// Raised from CalculateEqualPerPeriod procedure before inserting each deferral line. /// </remarks> [IntegrationEvent(false, false)] local procedure OnCalculateEqualPerPeriodOnBeforeDeferralLineInsert(DeferralHeader: Record "Deferral Header"; var DeferralLine: record "Deferral Line") begin end; /// <summary> /// Integration event raised after calculating the second period date in straight-line deferral calculations. /// Enables custom period date adjustments for straight-line deferral schedules. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="PostDate">Original posting date for the deferral</param> /// <param name="FirstPeriodDate">First period date for the deferral schedule</param> /// <param name="SecondPeriodDate">Second period date (can be modified by subscribers)</param> /// <remarks> /// Raised from CalculateStraightline procedure after calculating the second period date. /// </remarks> [IntegrationEvent(false, false)] local procedure OnCalculateStraightlineOnAfterCalcSecondPeriodDate(DeferralHeader: Record "Deferral Header"; PostDate: Date; var FirstPeriodDate: Date; var SecondPeriodDate: Date) begin end; /// <summary> /// Integration event raised before inserting deferral line during straight-line calculation. /// Enables custom field updates or validation before line insertion. /// </summary> /// <param name="DeferralLine">Deferral line record to be inserted</param> /// <param name="DeferralHeader">Deferral header context for the calculation</param> /// <remarks> /// Raised from CalculateStraightline procedure before inserting each deferral line. /// </remarks> [IntegrationEvent(false, false)] local procedure OnCalculateStraightlineOnBeforeDeferralLineInsert(var DeferralLine: Record "Deferral Line"; DeferralHeader: Record "Deferral Header") begin end; /// <summary> /// Integration event raised before calculating periodic deferral amount in straight-line method. /// Enables custom amount calculation logic for straight-line deferral periods. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="PeriodicDeferralAmount">Periodic deferral amount (can be modified by subscribers)</param> /// <param name="AmountRoundingPrecision">Rounding precision for amount calculations</param> /// <param name="IsHandled">Set to true to skip standard periodic amount calculation</param> /// <remarks> /// Raised from CalculateStraightline procedure before calculating periodic deferral amounts. /// </remarks> [IntegrationEvent(false, false)] local procedure OnCalculateStraightlineOnBeforeCalcPeriodicDeferralAmount(var DeferralHeader: Record "Deferral Header"; var PeriodicDeferralAmount: Decimal; AmountRoundingPrecision: Decimal; var IsHandled: Boolean); begin end; /// <summary> /// Integration event raised after calculating periodic deferral amount in straight-line method. /// Enables subscribers to control the number of loops within CalculateStraightline. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="NoOfLoops">Number of loop iterations (can be modified by subscribers)</param> /// <remarks> /// Raised from CalculateStraightline procedure after calculating the periodic deferral amount and before the loop starts. /// </remarks> [IntegrationEvent(false, false)] local procedure OnCalculateStraightlineOnAfterCalcPeriodicDeferralAmount(var DeferralHeader: Record "Deferral Header"; var NoOfLoops: Integer) begin end; /// <summary> /// Integration event raised after calculating end date for days per period deferral method. /// Enables custom end date adjustments for days-based deferral calculations. /// </summary> /// <param name="DeferralHeader">Deferral header record containing calculation parameters</param> /// <param name="DeferralLine">Deferral line record with calculated dates</param> /// <param name="DeferralTemplate">Deferral template containing calculation settings</param> /// <param name="EndDate">Calculated end date (can be modified by subscribers)</param> /// <remarks> /// Raised from CalculateDaysPerPeriod procedure after calculating period end date. /// </remarks> [IntegrationEvent(false, false)] local procedure OnCalculateDaysPerPeriodOnAfterCalcEndDate(var DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template"; var EndDate: Date) begin end; /// <summary> /// Integration event raised before inserting deferral line during days per period calculation. /// Enables custom field updates or validation before line insertion. /// </summary> /// <param name="DeferralHeader">Deferral header context for the calculation</param> /// <param name="DeferralLine">Deferral line record to be inserted</param> /// <remarks> /// Raised from CalculateDaysPerPeriod procedure before inserting each deferral line. /// </remarks> [IntegrationEvent(false, false)] local procedure OnCalculateDaysPerPeriodOnBeforeDeferralLineInsert(DeferralHeader: Record "Deferral Header"; var DeferralLine: record "Deferral Line") begin end; /// <summary> /// Integration event raised before inserting deferral line during user-defined calculation. /// Enables custom field updates or validation before line insertion. /// </summary> /// <param name="DeferralHeader">Deferral header context for the calculation</param> /// <param name="DeferralLine">Deferral line record to be inserted</param> /// <remarks> /// Raised from CalculateUserDefined procedure before inserting each deferral line. /// </remarks> [IntegrationEvent(false, false)] local procedure OnCalculateUserDefinedOnBeforeDeferralLineInsert(DeferralHeader: Record "Deferral Header"; var DeferralLine: record "Deferral Line") begin end; /// <summary> /// Integration event raised before modifying deferral header during record setup. /// Enables custom field updates or validation before deferral header modification. /// </summary> /// <param name="DeferralHeader">Deferral header record to be modified</param> /// <remarks> /// Raised from SetDeferralRecords procedure before modifying deferral header. /// </remarks> [IntegrationEvent(false, false)] local procedure OnSetDeferralRecordsOnBeforeDeferralHeaderModify(var DeferralHeader: Record "Deferral Header") begin end; /// <summary> /// Integration event raised before checking if a posting date is allowed for deferral processing. /// Enables custom date validation logic for deferral schedule processing. /// </summary> /// <param name="PostingDate">Posting date to be validated</param> /// <param name="Result">Validation result (can be modified by subscribers)</param> /// <param name="IsHandled">Set to true to skip standard date validation</param> /// <remarks> /// Raised from IsDateNotAllowed procedure before standard posting date validation. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeIsDateNotAllowed(PostingDate: Date; var Result: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Integration event raised before updating deferral line description during schedule creation. /// Enables custom description generation logic for deferral line entries. /// </summary> /// <param name="DeferralLine">Deferral line record to update</param> /// <param name="DeferralHeader">Deferral header context for description generation</param> /// <param name="DeferralTemplate">Deferral template containing description settings</param> /// <param name="PostDate">Posting date for the deferral line</param> /// <param name="IsHandled">Set to true to skip standard description update</param> /// <remarks> /// Raised from UpdateDeferralLineDescription procedure before updating line description. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateDeferralLineDescription(var DeferralLine: Record "Deferral Line"; DeferralHeader: Record "Deferral Header"; DeferralTemplate: Record "Deferral Template"; PostDate: Date; var IsHandled: Boolean) begin end; /// <summary> /// Integration event raised before validating deferral template settings. /// Enables custom validation logic for deferral template configuration. /// </summary> /// <param name="DeferralTemplate">Deferral template record to validate</param> /// <param name="IsHandled">Set to true to skip standard template validation</param> /// <remarks> /// Raised from ValidateDeferralTemplate procedure before standard template validation. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeValidateDeferralTemplate(DeferralTemplate: Record "Deferral Template"; var IsHandled: Boolean) begin end; /// <summary> /// Integration event raised after initializing deferral line during deferral header initialization. /// Enables custom field updates or additional processing after deferral line setup. /// </summary> /// <param name="DeferralLine">Deferral line record that was initialized</param> /// <remarks> /// Raised from InitializeDeferralHeaderAndSetPostDate procedure after initializing deferral line. /// </remarks> [IntegrationEvent(false, false)] local procedure OnInitializeDeferralHeaderAndSetPostDateAfterInitDeferralLine(var DeferralLine: Record "Deferral Line") begin end; /// <summary> /// Integration event raised after initializing deferral header and setting the post date. /// Enables custom control over the PostDate variable assignment. /// </summary> /// <param name="DeferralLine">Deferral line record that was initialized</param> /// <param name="DeferralHeader">Deferral header containing source information</param> /// <param name="PeriodicCount">Current period number in the deferral schedule</param> /// <param name="PostDate">Posting date that was set based on period calculations</param> /// <remarks> /// Raised from InitializeDeferralHeaderAndSetPostDate procedure after all initialization is complete. /// </remarks> [IntegrationEvent(false, false)] local procedure OnAfterInitializeDeferralHeaderAndSetPostDate(var DeferralLine: Record "Deferral Line"; DeferralHeader: Record "Deferral Header"; PeriodicCount: Integer; var PostDate: Date) begin end; /// <summary> /// Integration event raised before setting parameters for deferral schedule page during line editing. /// Enables custom parameter setup or validation before opening deferral schedule editor. /// </summary> /// <param name="DeferralSchedule">Deferral schedule page instance</param> /// <param name="DeferralDocType">Document type for the deferral</param> /// <param name="GenJnlTemplateName">General journal template name if applicable</param> /// <param name="GenJnlBatchName">General journal batch name if applicable</param> /// <param name="DocumentType">Document type identifier</param> /// <param name="DocumentNo">Document number for the deferral</param> /// <param name="DeferralHeader">Deferral header context for the schedule</param> /// <param name="IsHandled">Set to true to skip standard parameter setup</param> /// <remarks> /// Raised from OpenLineScheduleEdit procedure before setting deferral schedule parameters. /// </remarks> [IntegrationEvent(false, false)] local procedure OnOpenLineScheduleEditOnBeforeDeferralScheduleSetParameters(var DeferralSchedule: Page "Deferral Schedule"; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; DeferralHeader: Record "Deferral Header"; var IsHandled: Boolean) begin end; /// <summary> /// Integration event raised before checking deferral conditions for general journal lines. /// Enables custom deferral condition logic for journal line processing. /// </summary> /// <param name="GenJournalLine">General journal line to check for deferral conditions</param> /// <param name="IsHandled">Set to true to skip standard deferral condition checking</param> /// <remarks> /// Raised from CheckDeferralConditionForGenJournal procedure before standard condition validation. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeCheckDeferralConditionForGenJournal(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean) begin end; /// <summary> /// Integration event raised before removing or setting up deferral schedule for a document line. /// Enables custom deferral schedule management logic and validation. /// </summary> /// <param name="DeferralCode">Deferral template code for the schedule</param> /// <param name="DeferralDocType">Document type for the deferral</param> /// <param name="GenJnlTemplateName">General journal template name if applicable</param> /// <param name="GenJnlBatchName">General journal batch name if applicable</param> /// <param name="DocumentType">Document type identifier</param> /// <param name="DocumentNo">Document number for the deferral</param> /// <param name="LineNo">Line number within the document</param> /// <param name="Amount">Deferral amount</param> /// <param name="PostingDate">Posting date for the deferral</param> /// <param name="Description">Description for the deferral</param> /// <param name="CurrencyCode">Currency code for the deferral</param> /// <param name="AdjustStartDate">Whether to adjust the start date</param> /// <param name="IsHandled">Set to true to skip standard deferral schedule processing</param> /// <remarks> /// Raised from RemoveOrSetDeferralSchedule procedure before standard schedule management. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeRemoveOrSetDeferralSchedule(DeferralCode: Code[10]; DeferralDocType: Integer; GenJnlTemplateName: Code[10]; GenJnlBatchName: Code[10]; DocumentType: Integer; DocumentNo: Code[20]; LineNo: Integer; Amount: Decimal; PostingDate: Date; Description: Text[100]; CurrencyCode: Code[10]; AdjustStartDate: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeRoundDeferralAmount(var DeferralHeader: Record "Deferral Header"; CurrencyCode: Code[10]; CurrencyFactor: Decimal; PostingDate: Date; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreateDeferralScheduleOnCalcMethodElse(CalcMethod: Enum "Deferral Calculation Method"; DeferralHeader: Record "Deferral Header"; var DeferralLine: Record "Deferral Line"; DeferralTemplate: Record "Deferral Template") begin end; /// <summary> /// Integration event raised before determining the period starting date. /// Enables custom logic for returning the period starting date based on the posting date. /// </summary> /// <param name="PostingDate">Posting date used to determine the period starting date</param> /// <param name="Result">Period starting date result (can be modified by subscribers)</param> /// <param name="PeriodStartingDateHandled">Set to true to skip standard period starting date calculation</param> /// <remarks> /// Raised from GetPeriodStartingDate procedure before standard period date lookup. /// </remarks> [IntegrationEvent(false, false)] local procedure OnBeforeGetPeriodStartingDate(PostingDate: Date; var Result: Date; var PeriodStartingDateHandled: Boolean) begin end;}