Codeunit 230 GenJnlManagement

Base Application, Microsoft.Finance.GeneralLedger.Journal

src/Layers/W1/BaseApp/Finance/GeneralLedger/Journal/GenJnlManagement.Codeunit.al952 lines, Copyright (c) Microsoft Corporation. MIT

// ------------------------------------------------------------------------------------------------// Copyright (c) Microsoft Corporation. All rights reserved.// Licensed under the MIT License. See License.txt in the project root for license information.// ------------------------------------------------------------------------------------------------namespace Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Bank.BankAccount;using Microsoft.Finance.AllocationAccount;using Microsoft.Finance.Currency;using Microsoft.Finance.GeneralLedger.Account;using Microsoft.FixedAssets.FixedAsset;using Microsoft.HumanResources.Employee;using Microsoft.Intercompany.Partner;using Microsoft.Purchases.Vendor;using Microsoft.Sales.Customer;using Microsoft.Utilities;/// <summary>/// Provides comprehensive management functionality for general journal templates, batches, and line processing./// Handles template selection, batch management, account validation, and journal navigation workflows./// </summary>/// <remarks>/// Central management codeunit for journal operations including template selection, batch creation, and validation./// Key capabilities: Template selection logic, batch management, account name lookup, and journal page navigation./// Extensibility: Multiple integration events enable custom template selection logic and journal processing workflows./// </remarks>codeunit 230 GenJnlManagement{    Permissions = TableData "Gen. Journal Template" = rimd,                  TableData "Gen. Journal Batch" = rimd;    trigger OnRun()    begin    end;    var        [SecurityFiltering(SecurityFilter::Filtered)]        PrevGenJnlLine: Record "Gen. Journal Line";        OpenFromBatch: Boolean;        AccountNames: Dictionary of [Text, Text];#pragma warning disable AA0074        Text000: Label 'Fixed Asset G/L Journal';#pragma warning disable AA0470        Text001: Label '%1 journal';#pragma warning restore AA0470        Text002: Label 'RECURRING';        Text003: Label 'Recurring General Journal';        Text004: Label 'DEFAULT';        Text005: Label 'Default Journal';#pragma warning restore AA0074        SpendRequestRequiredMsg: Label 'A spend request no. should be specified for G/L account no. %1', Comment = '%1 is an account no.';    /// <summary>    /// Manages template selection for journal pages based on page type and recurring journal requirements.    /// Filters available templates and launches appropriate journal interface.    /// </summary>    /// <param name="PageID">Page identifier for the journal type being opened.</param>    /// <param name="PageTemplate">Template type enum that determines journal behavior.</param>    /// <param name="RecurringJnl">Boolean indicating if this is for recurring journal functionality.</param>    /// <param name="GenJnlLine">Journal line record used for context and filtering.</param>    /// <param name="JnlSelected">Returns true if a valid template was selected and journal opened.</param>    procedure TemplateSelection(PageID: Integer; PageTemplate: Enum "Gen. Journal Template Type"; RecurringJnl: Boolean; var GenJnlLine: Record "Gen. Journal Line"; var JnlSelected: Boolean)    var        [SecurityFiltering(SecurityFilter::Filtered)]        GenJnlTemplate: Record "Gen. Journal Template";        GenJnlTemplateType: Option;    begin        JnlSelected := true;        GenJnlTemplate.Reset();        GenJnlTemplate.SetRange("Page ID", PageID);        GenJnlTemplate.SetRange(Recurring, RecurringJnl);        if not RecurringJnl then            GenJnlTemplate.SetRange(Type, PageTemplate);        GenJnlTemplateType := PageTemplate.AsInteger();        OnTemplateSelectionSetFilter(GenJnlTemplate, GenJnlTemplateType, RecurringJnl, PageID, GenJnlLine);        PageTemplate := Enum::"Gen. Journal Template Type".FromInteger(GenJnlTemplateType);        JnlSelected := FindTemplateFromSelection(GenJnlTemplate, PageTemplate, RecurringJnl);        if JnlSelected then            RunTemplateJournalPage(GenJnlTemplate, GenJnlLine);        OnAfterTemplateSelection(GenJnlTemplate, GenJnlLine, JnlSelected, OpenFromBatch, RecurringJnl);    end;    local procedure RunTemplateJournalPage(var GenJnlTemplate: Record "Gen. Journal Template"; var GenJnlLine: Record "Gen. Journal Line")    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeRunTemplateJournalPage(GenJnlTemplate, GenJnlLine, OpenFromBatch, IsHandled);        if IsHandled then            exit;        GenJnlLine.FilterGroup := 2;        GenJnlLine.SetRange("Journal Template Name", GenJnlTemplate.Name);        GenJnlLine.FilterGroup := 0;        if OpenFromBatch then begin            GenJnlLine."Journal Template Name" := '';            PAGE.Run(GenJnlTemplate."Page ID", GenJnlLine);        end;    end;    /// <summary>    /// Opens journal interface directly from a batch selection, bypassing template selection.    /// Validates batch configuration and launches the appropriate journal page.    /// </summary>    /// <param name="GenJnlBatch">Journal batch record containing template reference and batch settings.</param>    procedure TemplateSelectionFromBatch(var GenJnlBatch: Record "Gen. Journal Batch")    var        [SecurityFiltering(SecurityFilter::Filtered)]        GenJnlTemplate: Record "Gen. Journal Template";    begin        OpenFromBatch := true;        GenJnlTemplate.Get(GenJnlBatch."Journal Template Name");        GenJnlTemplate.TestField("Page ID");        GenJnlBatch.TestField(Name);        OpenJournalPageFromBatch(GenJnlBatch, GenJnlTemplate);    end;    local procedure OpenJournalPageFromBatch(var GenJnlBatch: Record "Gen. Journal Batch"; GenJnlTemplate: Record "Gen. Journal Template")    var        [SecurityFiltering(SecurityFilter::Filtered)]        GenJnlLine: Record "Gen. Journal Line";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeOpenJournalPageFromBatch(GenJnlBatch, GenJnlTemplate, IsHandled);        if IsHandled then            exit;        GenJnlLine.FilterGroup := 2;        GenJnlLine.SetRange("Journal Template Name", GenJnlTemplate.Name);        GenJnlLine.FilterGroup := 0;        GenJnlLine."Journal Template Name" := '';        GenJnlLine."Journal Batch Name" := GenJnlBatch.Name;        PAGE.Run(GenJnlTemplate."Page ID", GenJnlLine);    end;    /// <summary>    /// Opens journal batch with current batch name and manages batch selection logic.    /// Handles batch validation and provides default batch creation when necessary.    /// </summary>    /// <param name="CurrentJnlBatchName">Current journal batch name to open or validate.</param>    /// <param name="GenJnlLine">Journal line record for context and template information.</param>    procedure OpenJnl(var CurrentJnlBatchName: Code[10]; var GenJnlLine: Record "Gen. Journal Line")    begin        OnBeforeOpenJnl(CurrentJnlBatchName, GenJnlLine);        if (GenJnlLine."Journal Template Name" <> '') and (GenJnlLine.GetFilter("Journal Template Name") = '') then            CheckTemplateName(GenJnlLine."Journal Template Name", CurrentJnlBatchName)        else            CheckTemplateName(GenJnlLine.GetRangeMax("Journal Template Name"), CurrentJnlBatchName);        OnOpenJnlOnAfterCheckTemplateName(GenJnlLine, CurrentJnlBatchName);        GenJnlLine.FilterGroup := 2;        GenJnlLine.SetRange("Journal Batch Name", CurrentJnlBatchName);        GenJnlLine.FilterGroup := 0;    end;    /// <summary>    /// Opens and initializes a general journal batch with template selection and validation.    /// Ensures proper batch setup by creating missing templates and handling batch selection logic.    /// </summary>    /// <param name="GenJnlBatch">General journal batch record to open and configure</param>    procedure OpenJnlBatch(var GenJnlBatch: Record "Gen. Journal Batch")    var        [SecurityFiltering(SecurityFilter::Filtered)]        GenJnlTemplate: Record "Gen. Journal Template";        [SecurityFiltering(SecurityFilter::Filtered)]        GenJnlLine: Record "Gen. Journal Line";        JnlSelected: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeOpenJnlBatch(GenJnlBatch, IsHandled);        if not IsHandled then begin            if GenJnlBatch.GetFilter("Journal Template Name") <> '' then                exit;            GenJnlBatch.FilterGroup(2);            if GenJnlBatch.GetFilter("Journal Template Name") <> '' then begin                GenJnlBatch.FilterGroup(0);                exit;            end;            GenJnlBatch.FilterGroup(0);            if not GenJnlBatch.Find('-') then                for GenJnlTemplate.Type := GenJnlTemplate.Type::General to GenJnlTemplate.Type::Jobs do begin                    GenJnlTemplate.SetRange(Type, GenJnlTemplate.Type);                    if not GenJnlTemplate.FindFirst() then                        TemplateSelection(0, GenJnlTemplate.Type, false, GenJnlLine, JnlSelected);                    if GenJnlTemplate.FindFirst() then                        CheckTemplateName(GenJnlTemplate.Name, GenJnlBatch.Name);                    if GenJnlTemplate.Type = GenJnlTemplate.Type::General then begin                        GenJnlTemplate.SetRange(Recurring, true);                        if not GenJnlTemplate.FindFirst() then                            TemplateSelection(0, GenJnlTemplate.Type, true, GenJnlLine, JnlSelected);                        if GenJnlTemplate.FindFirst() then                            CheckTemplateName(GenJnlTemplate.Name, GenJnlBatch.Name);                        GenJnlTemplate.SetRange(Recurring);                    end;                end;            GenJnlBatch.Find('-');            JnlSelected := true;            GenJnlBatch.CalcFields("Template Type", Recurring);            GenJnlTemplate.SetRange(Recurring, GenJnlBatch.Recurring);            if not GenJnlBatch.Recurring then                GenJnlTemplate.SetRange(Type, GenJnlBatch."Template Type");            if GenJnlBatch.GetFilter("Journal Template Name") <> '' then                GenJnlTemplate.SetRange(Name, GenJnlBatch.GetFilter("Journal Template Name"));            OnOpenJnlBatchOnBeforeCheckGenJnlTemplateCount(GenJnlBatch, GenJnlTemplate);            case GenJnlTemplate.Count of                1:                    GenJnlTemplate.FindFirst();                else                    JnlSelected := PAGE.RunModal(0, GenJnlTemplate) = ACTION::LookupOK;            end;            if not JnlSelected then                Error('');            GenJnlBatch.FilterGroup(0);            GenJnlBatch.SetRange("Journal Template Name", GenJnlTemplate.Name);            GenJnlBatch.FilterGroup(2);        end;        OnAfterOpenJournalBatch(GenJnlBatch, GenJnlTemplate);    end;    /// <summary>    /// Checks if the journal batch has an empty number series configuration.    /// Validates whether the batch requires manual document numbering or has automatic numbering configured.    /// </summary>    /// <param name="CurrentJnlBatchName">Journal batch name to check for number series configuration</param>    /// <param name="GenJnlLine">Journal line record providing template context for batch lookup</param>    /// <returns>True if the batch number series is empty, false if number series is configured</returns>    procedure IsBatchNoSeriesEmpty(var CurrentJnlBatchName: Code[10]; var GenJnlLine: Record "Gen. Journal Line"): Boolean    var        GenJnlBatch: Record "Gen. Journal Batch";    begin        if (GenJnlLine."Journal Template Name" <> '') and (GenJnlLine.GetFilter("Journal Template Name") = '') then            GenJnlBatch.get(GenJnlLine."Journal Template Name", CurrentJnlBatchName)        else            if GenJnlBatch.get(GenJnlLine.GetRangeMax("Journal Template Name"), CurrentJnlBatchName) then;        exit(GenJnlBatch."No. Series" = '');    end;    [Scope('OnPrem')]    procedure CheckTemplateName(CurrentJnlTemplateName: Code[10]; var CurrentJnlBatchName: Code[10])    var        [SecurityFiltering(SecurityFilter::Filtered)]        GenJnlBatch: Record "Gen. Journal Batch";    begin        GenJnlBatch.SetRange("Journal Template Name", CurrentJnlTemplateName);        if not GenJnlBatch.Get(CurrentJnlTemplateName, CurrentJnlBatchName) then begin            if not GenJnlBatch.FindFirst() then begin                GenJnlBatch.Init();                GenJnlBatch."Journal Template Name" := CurrentJnlTemplateName;                GenJnlBatch.SetupNewBatch();                GenJnlBatch.Name := Text004;                GenJnlBatch.Description := Text005;                GenJnlBatch.Insert(true);                Commit();            end;            CurrentJnlBatchName := GenJnlBatch.Name        end;    end;    /// <summary>    /// Validates journal batch exists and gets batch configuration for the specified batch name.    /// Ensures batch is properly configured before allowing journal operations.    /// </summary>    /// <param name="CurrentJnlBatchName">Journal batch name to validate and check.</param>    /// <param name="GenJnlLine">Journal line record for template context.</param>    procedure CheckName(CurrentJnlBatchName: Code[10]; var GenJnlLine: Record "Gen. Journal Line")    var        GenJnlBatch: Record "Gen. Journal Batch";    begin        GenJnlBatch.Get(GenJnlLine.GetRangeMax("Journal Template Name"), CurrentJnlBatchName);        OnAfterCheckName(GenJnlBatch, CurrentJnlBatchName, GenJnlLine);    end;    /// <summary>    /// Validates currency code exists in the currency master data.    /// Provides currency validation for journal line processing.    /// </summary>    /// <param name="CurrencyCode">Currency code to validate against currency table.</param>    procedure CheckCurrencyCode(CurrencyCode: Code[10])    var        Currency: Record Currency;    begin        Currency.Get(CurrencyCode);    end;    /// <summary>    /// Sets journal batch filter on journal lines and positions to first record.    /// Configures journal line record for batch-specific operations.    /// </summary>    /// <param name="CurrentJnlBatchName">Journal batch name to filter on.</param>    /// <param name="GenJnlLine">Journal line record to configure with batch filter.</param>    procedure SetName(CurrentJnlBatchName: Code[10]; var GenJnlLine: Record "Gen. Journal Line")    begin        GenJnlLine.FilterGroup := 2;        GenJnlLine.SetRange("Journal Batch Name", CurrentJnlBatchName);        GenJnlLine.FilterGroup := 0;        OnAfterSetName(GenJnlLine, CurrentJnlBatchName);        if GenJnlLine.Find('-') then;    end;    /// <summary>    /// Configures journal page display mode preference for the current user.    /// Stores user preference for simple or classic view mode in journal pages.    /// </summary>    /// <param name="SetToSimpleMode">True to set simple mode, false for classic mode.</param>    /// <param name="PageIdToSet">Page identifier to set the preference for.</param>    procedure SetJournalSimplePageModePreference(SetToSimpleMode: Boolean; PageIdToSet: Integer)    var        JournalUserPreferences: Record "Journal User Preferences";        IsHandled: Boolean;    begin        // sets journal page preference for a page        // preference set to simple page if SetToSimpleMode is true; else set to classic mode        IsHandled := false;        OnBeforeSetJournalSimplePageModePreference(SetToSimpleMode, PageIdToSet, IsHandled);        if IsHandled then            exit;        JournalUserPreferences.Reset();        JournalUserPreferences.SetFilter("User ID", '%1', UserSecurityId());        JournalUserPreferences.SetFilter("Page ID", '%1', PageIdToSet);        if JournalUserPreferences.FindFirst() then begin            JournalUserPreferences."Is Simple View" := SetToSimpleMode;            JournalUserPreferences.Modify();        end else begin            Clear(JournalUserPreferences);            JournalUserPreferences."Page ID" := PageIdToSet;            JournalUserPreferences."Is Simple View" := SetToSimpleMode;            JournalUserPreferences."User ID" := UserSecurityId();            JournalUserPreferences.Insert();        end;    end;    /// <summary>    /// Retrieves journal page display mode preference for the current user.    /// Returns user preference for simple or classic view mode in journal pages.    /// </summary>    /// <param name="PageIdToCheck">Page identifier to check preference for.</param>    /// <returns>True if simple mode is preferred, false for classic mode or if no preference set.</returns>    procedure GetJournalSimplePageModePreference(PageIdToCheck: Integer): Boolean    var        JournalUserPreferences: Record "Journal User Preferences";    begin        // Get journal page mode preference for a page; By defaults this returns FALSE unless a preference        // is set        OnBeforeGetJournalSimplePageModePreference(PageIdToCheck);        JournalUserPreferences.Reset();        JournalUserPreferences.SetFilter("User ID", '%1', UserSecurityId());        JournalUserPreferences.SetFilter("Page ID", '%1', PageIdToCheck);        if JournalUserPreferences.FindFirst() then            exit(JournalUserPreferences."Is Simple View");        exit(false);    end;    /// <summary>    /// Retrieves the last viewed journal batch name for a specific page from user preferences.    /// Returns stored user preference for batch selection when reopening journal pages.    /// </summary>    /// <param name="PageIdToCheck">Page identifier to retrieve batch preference for.</param>    /// <returns>Last viewed journal batch name for the page, or empty string if no preference stored.</returns>    procedure GetLastViewedJournalBatchName(PageIdToCheck: Integer): Code[10]    var        JournalUserPreferences: Record "Journal User Preferences";    begin        JournalUserPreferences.Reset();        JournalUserPreferences.SetFilter("User ID", '%1', UserSecurityId());        JournalUserPreferences.SetFilter("Page ID", '%1', PageIdToCheck);        if JournalUserPreferences.FindFirst() then            exit(JournalUserPreferences."Journal Batch Name");        exit('');    end;    /// <summary>    /// Stores the last viewed journal batch name for a specific page in user preferences.    /// Updates user preference for batch selection to improve user experience on page reopening.    /// </summary>    /// <param name="PageIdToCheck">Page identifier to set batch preference for.</param>    /// <param name="GenJnlBatch">Journal batch name to store as last viewed preference.</param>    procedure SetLastViewedJournalBatchName(PageIdToCheck: Integer; GenJnlBatch: Code[10])    var        JournalUserPreferences: Record "Journal User Preferences";    begin        JournalUserPreferences.Reset();        JournalUserPreferences.SetFilter("User ID", '%1', UserSecurityId());        JournalUserPreferences.SetFilter("Page ID", '%1', PageIdToCheck);        if JournalUserPreferences.FindFirst() then begin            JournalUserPreferences."Journal Batch Name" := GenJnlBatch;            JournalUserPreferences.Modify();        end;    end;    /// <summary>    /// Provides journal batch lookup functionality with filtering and selection capabilities.    /// Opens batch selection page and updates current batch name based on user selection.    /// </summary>    /// <param name="CurrentJnlBatchName">Current journal batch name that will be updated with selection.</param>    /// <param name="GenJnlLine">Journal line record providing template context for batch filtering.</param>    procedure LookupName(var CurrentJnlBatchName: Code[10]; var GenJnlLine: Record "Gen. Journal Line")    var        GenJnlBatch: Record "Gen. Journal Batch";    begin        Commit();        GenJnlBatch."Journal Template Name" := GenJnlLine.GetRangeMax("Journal Template Name");        GenJnlBatch.Name := GenJnlLine.GetRangeMax("Journal Batch Name");        GenJnlBatch.FilterGroup(2);        GenJnlBatch.SetRange("Journal Template Name", GenJnlBatch."Journal Template Name");        GenJnlBatch.FilterGroup(0);        OnBeforeLookupName(GenJnlBatch, GenJnlLine);        if PAGE.RunModal(0, GenJnlBatch) = ACTION::LookupOK then begin            CurrentJnlBatchName := GenJnlBatch.Name;            SetName(CurrentJnlBatchName, GenJnlLine);        end;    end;    /// <summary>    /// Opens journal batch name lookup and updates journal line batch assignment.    /// Provides user interface for selecting and assigning journal batch to current line.    /// </summary>    /// <param name="GenJnlLine">Journal line record that will have batch name updated from selection.</param>    procedure SetJnlBatchName(var GenJnlLine: Record "Gen. Journal Line")    var        GenJnlBatch: Record "Gen. Journal Batch";    begin        GenJnlLine.TestField("Journal Template Name");        GenJnlBatch.FilterGroup(2);        GenJnlBatch.SetRange("Journal Template Name", GenJnlLine."Journal Template Name");        GenJnlBatch."Journal Template Name" := GenJnlLine."Journal Template Name";        GenJnlBatch.FilterGroup(0);        GenJnlBatch.Name := GenJnlLine."Journal Batch Name";        if PAGE.RunModal(0, GenJnlBatch) = ACTION::LookupOK then            GenJnlLine."Journal Batch Name" := GenJnlBatch.Name;    end;    /// <summary>    /// Retrieves and caches account names for display in journal lines to improve user experience.    /// Optimizes performance by caching account names to avoid repeated database lookups.    /// </summary>    /// <param name="GenJnlLine">Journal line record containing account information.</param>    /// <param name="AccName">Returns the account name for the primary account.</param>    /// <param name="BalAccName">Returns the account name for the balancing account.</param>    procedure GetAccounts(var GenJnlLine: Record "Gen. Journal Line"; var AccName: Text[100]; var BalAccName: Text[100])    begin        if (GenJnlLine."Account Type" <> PrevGenJnlLine."Account Type") or           (GenJnlLine."Account No." <> PrevGenJnlLine."Account No.")        then begin            AccName := '';            if GenJnlLine."Account No." <> '' then                AccName := GetAccountName(GenJnlLine."Account Type", GenJnlLine."Account No.");        end;        if (GenJnlLine."Bal. Account Type" <> PrevGenJnlLine."Bal. Account Type") or           (GenJnlLine."Bal. Account No." <> PrevGenJnlLine."Bal. Account No.")        then begin            BalAccName := '';            if GenJnlLine."Bal. Account No." <> '' then                BalAccName := GetAccountName(GenJnlLine."Bal. Account Type", GenJnlLine."Bal. Account No.");        end;        OnAfterGetAccounts(GenJnlLine, AccName, BalAccName);        PrevGenJnlLine := GenJnlLine;    end;    local procedure GetAccountName(AccType: Enum "Gen. Journal Account Type"; AccNo: Code[20]): Text[100]    var        KeyName: Text;        AccName: Text[100];    begin        if AccNo = '' then            exit('');        KeyName := Format(AccType.AsInteger()) + '$' + AccNo;        if AccountNames.ContainsKey(KeyName) then            AccName := CopyStr(AccountNames.Get(KeyName), 1, MaxStrLen(AccName))        else begin            AccName := LookupAccountName(AccType, AccNo);            AccountNames.Add(KeyName, AccName);        end;        exit(AccName);    end;    local procedure LookupAccountName(AccType: Enum "Gen. Journal Account Type"; AccNo: Code[20]): Text[100]    var        [SecurityFiltering(SecurityFilter::Filtered)]        GLAcc: Record "G/L Account";        [SecurityFiltering(SecurityFilter::Filtered)]        Cust: Record Customer;        [SecurityFiltering(SecurityFilter::Filtered)]        Vend: Record Vendor;        [SecurityFiltering(SecurityFilter::Filtered)]        BankAcc: Record "Bank Account";        [SecurityFiltering(SecurityFilter::Filtered)]        FA: Record "Fixed Asset";        [SecurityFiltering(SecurityFilter::Filtered)]        ICPartner: Record "IC Partner";        [SecurityFiltering(SecurityFilter::Filtered)]        Employee: Record Employee;        [SecurityFiltering(SecurityFilter::Filtered)]        AllocationAccount: Record "Allocation Account";        AccName: Text[100];    begin        case AccType of            AccType::"G/L Account":                begin                    GLAcc.SetloadFields(Name);                    if GLAcc.Get(AccNo) then                        AccName := GLAcc.Name;                end;            AccType::Customer:                begin                    Cust.SetloadFields(Name);                    if Cust.Get(AccNo) then                        AccName := Cust.Name;                end;            AccType::Vendor:                begin                    Vend.SetloadFields(Name);                    if Vend.Get(AccNo) then                        AccName := Vend.Name;                end;            AccType::"Bank Account":                begin                    BankAcc.SetloadFields(Name);                    if BankAcc.Get(AccNo) then                        AccName := BankAcc.Name;                end;            AccType::"Fixed Asset":                begin                    FA.SetloadFields(Description);                    if FA.Get(AccNo) then                        AccName := FA.Description;                end;            AccType::"IC Partner":                begin                    ICPartner.SetloadFields(Name);                    if ICPartner.Get(AccNo) then                        AccName := ICPartner.Name;                end;            AccType::Employee:                begin                    Employee.SetloadFields("First Name", "Last Name");                    if Employee.Get(AccNo) then                        AccName := Employee."First Name" + ' ' + Employee."Last Name";                end;            AccType::"Allocation Account":                begin                    AllocationAccount.SetloadFields(Name);                    if AllocationAccount.Get(AccNo) then                        AccName := AllocationAccount.Name;                end;        end;        exit(AccName);    end;    /// <summary>    /// Calculates running balance and total balance for journal lines within the current batch context.    /// Provides balance calculations for journal line display and validation purposes.    /// </summary>    /// <param name="GenJnlLine">Current journal line for balance calculation context.</param>    /// <param name="LastGenJnlLine">Last journal line used for calculation positioning.</param>    /// <param name="Balance">Returns the running balance up to the current line.</param>    /// <param name="TotalBalance">Returns the total balance for all lines in the batch.</param>    /// <param name="ShowBalance">Returns true if running balance should be displayed.</param>    /// <param name="ShowTotalBalance">Returns true if total balance should be displayed.</param>    procedure CalcBalance(var GenJnlLine: Record "Gen. Journal Line"; LastGenJnlLine: Record "Gen. Journal Line"; var Balance: Decimal; var TotalBalance: Decimal; var ShowBalance: Boolean; var ShowTotalBalance: Boolean)    var        [SecurityFiltering(SecurityFilter::Filtered)]        TempGenJnlLine: Record "Gen. Journal Line";    begin        TempGenJnlLine.CopyFilters(GenJnlLine);        OnCalcBalanceOnAfterCopyFilters(TempGenJnlLine);        if CurrentClientType in [CLIENTTYPE::SOAP, CLIENTTYPE::OData, CLIENTTYPE::ODataV4, CLIENTTYPE::Api] then            ShowTotalBalance := false        else            ShowTotalBalance := TempGenJnlLine.CalcSums("Balance (LCY)");        if ShowTotalBalance then begin            TotalBalance := TempGenJnlLine."Balance (LCY)";            if GenJnlLine."Line No." = 0 then                TotalBalance := TotalBalance + LastGenJnlLine."Balance (LCY)";        end;        if GenJnlLine."Line No." <> 0 then begin            TempGenJnlLine.SetRange("Line No.", 0, GenJnlLine."Line No.");            ShowBalance := TempGenJnlLine.CalcSums("Balance (LCY)");            if ShowBalance then                Balance := TempGenJnlLine."Balance (LCY)";        end else begin            TempGenJnlLine.SetRange("Line No.", 0, LastGenJnlLine."Line No.");            ShowBalance := TempGenJnlLine.CalcSums("Balance (LCY)");            if ShowBalance then begin                Balance := TempGenJnlLine."Balance (LCY)";                TempGenJnlLine.CopyFilters(GenJnlLine);                TempGenJnlLine := LastGenJnlLine;                OnCalcBalanceOnBeforeTempGenJnlLineNext(TempGenJnlLine);                if TempGenJnlLine.Next() = 0 then                    Balance := Balance + LastGenJnlLine."Balance (LCY)";            end;        end;        if CurrentClientType in [CLIENTTYPE::SOAP, CLIENTTYPE::OData, CLIENTTYPE::ODataV4, CLIENTTYPE::Api] then            ShowBalance := false;        OnAfterCalcBalance(GenJnlLine);    end;    procedure CalcBatchTotal(var GenJnlLine: Record "Gen. Journal Line"; var BatchTotal: Decimal; var ShowBatchTotal: Boolean)    var        [SecurityFiltering(SecurityFilter::Filtered)]        TotalGenJnlLine: Record "Gen. Journal Line";    begin        BatchTotal := 0;        ShowBatchTotal := not (CurrentClientType in [CLIENTTYPE::SOAP, CLIENTTYPE::OData, CLIENTTYPE::ODataV4, CLIENTTYPE::Api]);        if not ShowBatchTotal then            exit;        TotalGenJnlLine.CopyFilters(GenJnlLine);        TotalGenJnlLine.CalcSums("Amount (LCY)");        BatchTotal := TotalGenJnlLine."Amount (LCY)";    end;    /// <summary>    /// Generates unique journal template names by checking for conflicts and incrementing names when needed.    /// Ensures new template names are unique while maintaining meaningful naming based on template type.    /// </summary>    /// <param name="TemplateName">Proposed template name to check for availability.</param>    /// <returns>Available template name, either original or incremented to avoid conflicts.</returns>    procedure GetAvailableGeneralJournalTemplateName(TemplateName: Code[10]): Code[10]    var        GenJnlTemplate: Record "Gen. Journal Template";        PotentialTemplateName: Code[10];        PotentialTemplateNameIncrement: Integer;    begin        // Make sure proposed value + incrementer will fit in Name field        if StrLen(TemplateName) > 9 then            TemplateName := Format(TemplateName, 9);        GenJnlTemplate.Init();        PotentialTemplateName := TemplateName;        PotentialTemplateNameIncrement := 0;        // Expecting few naming conflicts, but limiting to 10 iterations to avoid possible infinite loop.        while PotentialTemplateNameIncrement < 10 do begin            GenJnlTemplate.SetFilter(Name, PotentialTemplateName);            if GenJnlTemplate.Count = 0 then                exit(PotentialTemplateName);            PotentialTemplateNameIncrement := PotentialTemplateNameIncrement + 1;            PotentialTemplateName := TemplateName + Format(PotentialTemplateNameIncrement);        end;    end;    local procedure FindTemplateFromSelection(var GenJnlTemplate: Record "Gen. Journal Template"; TemplateType: Enum "Gen. Journal Template Type"; RecurringJnl: Boolean) TemplateSelected: Boolean    begin        TemplateSelected := true;        case GenJnlTemplate.Count of            0:                begin                    GenJnlTemplate.Init();                    GenJnlTemplate.Type := TemplateType;                    GenJnlTemplate.Recurring := RecurringJnl;                    if not RecurringJnl then begin                        GenJnlTemplate.Name :=                          GetAvailableGeneralJournalTemplateName(Format(GenJnlTemplate.Type, MaxStrLen(GenJnlTemplate.Name)));                        if TemplateType = GenJnlTemplate.Type::Assets then                            GenJnlTemplate.Description := Text000                        else                            GenJnlTemplate.Description := StrSubstNo(Text001, GenJnlTemplate.Type);                    end else begin                        GenJnlTemplate.Name := Text002;                        GenJnlTemplate.Description := Text003;                    end;                    GenJnlTemplate.Validate(Type);                    OnFindTemplateFromSelectionOnBeforeGenJnlTemplateInsert(GenJnlTemplate);                    GenJnlTemplate.Insert();                    Commit();                end;            1:                GenJnlTemplate.FindFirst();            else                TemplateSelected := PAGE.RunModal(0, GenJnlTemplate) = ACTION::LookupOK;        end;    end;    [Scope('OnPrem')]    procedure TemplateSelectionSimple(var GenJnlTemplate: Record "Gen. Journal Template"; TemplateType: Enum "Gen. Journal Template Type"; RecurringJnl: Boolean): Boolean    begin        GenJnlTemplate.Reset();        GenJnlTemplate.SetRange(Type, TemplateType);        GenJnlTemplate.SetRange(Recurring, RecurringJnl);        exit(FindTemplateFromSelection(GenJnlTemplate, TemplateType, RecurringJnl));    end;    /// <summary>    /// Used from journal pages and warns users of need to specify spend request no.    /// </summary>    /// <param name="GLAccountNo"></param>    /// <param name="NotificationID"></param>    internal procedure ShowNotificationIfSpendRequestIsRequired(GLAccountNo: Code[20]; SpendRequestNo: Code[20]; var NotificationID: Guid)    var        GLAccount: Record "G/L Account";        Notification: Notification;    begin        if not IsNullGuid(NotificationID) then begin            Notification.Id := NotificationID;            if Notification.Recall() then;            Clear(NotificationID);        end;        if SpendRequestNo <> '' then            exit;        GLAccount.SetLoadFields("Spend Request Required");        if not GLAccount.Get(GLAccountNo) then            exit;        if GLAccount."Spend Request Required" = GLAccount."Spend Request Required"::None then            exit;        NotificationID := CreateGuid();        Notification.Id := NotificationID;        Notification.Message := StrSubstNo(SpendRequestRequiredMsg, GLAccountNo);        Notification.Send();    end;    /// <summary>    /// Integration event raised after retrieving account names for journal line display.    /// Enables customization of account name lookup and display logic.    /// </summary>    /// <param name="GenJournalLine">Journal line record containing account information.</param>    /// <param name="AccName">Account name for the primary account that can be modified.</param>    /// <param name="BalAccName">Balancing account name that can be modified.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterGetAccounts(var GenJournalLine: Record "Gen. Journal Line"; var AccName: Text[100]; var BalAccName: Text[100])    begin    end;    /// <summary>    /// Integration event raised after validating journal batch name exists and is properly configured.    /// Enables custom batch validation logic and post-validation processing.    /// </summary>    /// <param name="GenJnlBatch">Journal batch record that was validated.</param>    /// <param name="CurrentJnlBatchName">Current journal batch name being validated.</param>    /// <param name="GenJournalLine">Journal line record providing template context.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckName(GenJnlBatch: Record "Gen. Journal Batch"; CurrentJnlBatchName: Code[10]; var GenJournalLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Integration event raised after setting journal batch filter on journal lines.    /// Enables custom filtering logic and post-filter processing.    /// </summary>    /// <param name="GenJournalLine">Journal line record with batch filter applied.</param>    /// <param name="CurrentJnlBatchName">Journal batch name that was set as filter.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSetName(var GenJournalLine: Record "Gen. Journal Line"; CurrentJnlBatchName: Code[10])    begin    end;    /// <summary>    /// Integration event raised after opening journal batch operations complete.    /// Enables custom logic after batch and template have been selected and configured.    /// </summary>    /// <param name="GenJnlBatch">Journal batch record that was opened.</param>    /// <param name="GenJnlTemplate">Journal template record associated with the batch.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterOpenJournalBatch(GenJnlBatch: Record "Gen. Journal Batch"; GenJnlTemplate: Record "Gen. Journal Template")    begin    end;    /// <summary>    /// Integration event raised after template selection process completes.    /// Enables custom logic after template selection and journal page launch.    /// </summary>    /// <param name="GenJnlTemplate">Selected journal template record.</param>    /// <param name="GenJnlLine">Journal line record used for context.</param>    /// <param name="JnlSelected">Boolean indicating if template selection was successful.</param>    /// <param name="OpenFromBatch">Boolean indicating if opened from batch context.</param>    /// <param name="RecurringJnl">Boolean indicating if this is for recurring journal.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterTemplateSelection(var GenJnlTemplate: Record "Gen. Journal Template"; var GenJnlLine: Record "Gen. Journal Line"; var JnlSelected: Boolean; var OpenFromBatch: Boolean; RecurringJnl: Boolean)    begin    end;    /// <summary>    /// Integration event raised before journal batch name lookup operations.    /// Enables custom filtering or validation logic before batch selection.    /// </summary>    /// <param name="GenJnlBatch">Journal batch record that will be used for lookup.</param>    /// <param name="GenJnlLine">Journal line record providing context for lookup.</param>      [IntegrationEvent(false, false)]    local procedure OnBeforeLookupName(var GenJnlBatch: Record "Gen. Journal Batch"; var GenJnlLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Integration event raised before retrieving journal simple page mode preference.    /// Enables custom logic before preference retrieval.    /// </summary>    /// <param name="PageIdToCheck">Page identifier to check preference for.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeGetJournalSimplePageModePreference(PageIdToCheck: Integer)    begin    end;    /// <summary>    /// Integration event raised before setting journal simple page mode preference.    /// Enables custom validation or modification of preference settings.    /// </summary>    /// <param name="SetToSimpleMode">Boolean indicating simple mode preference (can be modified).</param>    /// <param name="PageIdToSet">Page identifier to set preference for.</param>    /// <param name="IsHandled">Set to true to skip standard preference setting logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSetJournalSimplePageModePreference(var SetToSimpleMode: Boolean; PageIdToSet: Integer; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before opening journal with batch name operations.    /// Enables custom validation or preprocessing before journal opening.    /// </summary>    /// <param name="CurrentJnlBatchName">Current journal batch name being opened.</param>    /// <param name="GenJnlLine">Journal line record providing context.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeOpenJnl(var CurrentJnlBatchName: Code[10]; var GenJnlLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Integration event raised before journal batch opening operations.    /// Enables custom logic to completely override batch opening process.    /// </summary>    /// <param name="GenJnlBatch">Journal batch record being opened.</param>    /// <param name="IsHandled">Set to true to skip standard batch opening logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeOpenJnlBatch(var GenJnlBatch: Record "Gen. Journal Batch"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before opening journal page from batch context.    /// Enables custom logic to override page opening from batch selection.    /// </summary>    /// <param name="GenJnlBatch">Journal batch record being opened.</param>    /// <param name="GenJnlTemplate">Journal template record associated with batch.</param>    /// <param name="IsHandled">Set to true to skip standard page opening logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeOpenJournalPageFromBatch(var GenJnlBatch: Record "Gen. Journal Batch"; var GenJnlTemplate: Record "Gen. Journal Template"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before running template journal page operations.    /// Enables custom logic to override journal page launching.    /// </summary>    /// <param name="GenJnlTemplate">Journal template record for page launching.</param>    /// <param name="GenJnlLine">Journal line record providing context.</param>    /// <param name="OpenFromBatch">Boolean indicating if opened from batch context.</param>    /// <param name="IsHandled">Set to true to skip standard page launching logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeRunTemplateJournalPage(var GenJnlTemplate: Record "Gen. Journal Template"; var GenJnlLine: Record "Gen. Journal Line"; OpenFromBatch: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised during template selection to enable custom filtering logic.    /// Allows modification of template filters and selection criteria.    /// </summary>    /// <param name="GenJnlTemplate">Journal template record with filters that can be modified.</param>    /// <param name="PageTemplate">Template type option that can be modified.</param>    /// <param name="RecurringJnl">Boolean indicating recurring journal that can be modified.</param>    /// <param name="PageId">Page identifier for template selection context.</param>    /// <param name="GenJnlLine">Journal line record providing context.</param>    [IntegrationEvent(false, false)]    local procedure OnTemplateSelectionSetFilter(var GenJnlTemplate: Record "Gen. Journal Template"; var PageTemplate: Option; var RecurringJnl: Boolean; PageId: Integer; var GenJnlLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Integration event raised before inserting a new journal template during template selection.    /// Enables custom template configuration before insertion.    /// </summary>    /// <param name="GenJnlTemplate">Journal template record being inserted that can be modified.</param>    [IntegrationEvent(false, false)]    local procedure OnFindTemplateFromSelectionOnBeforeGenJnlTemplateInsert(var GenJnlTemplate: Record "Gen. Journal Template")    begin    end;    /// <summary>    /// Integration event raised after template name checking during journal opening.    /// Enables custom processing after template validation.    /// </summary>    /// <param name="GenJournalLine">Journal line record with template context.</param>    /// <param name="CurrentJnlBatchName">Current journal batch name being processed.</param>    [IntegrationEvent(false, false)]    local procedure OnOpenJnlOnAfterCheckTemplateName(var GenJournalLine: Record "Gen. Journal Line"; var CurrentJnlBatchName: Code[10])    begin    end;    /// <summary>    /// Integration event raised before checking journal template count during batch operations.    /// Enables custom template filtering or validation logic.    /// </summary>    /// <param name="GenJnlBatch">Journal batch record being processed.</param>    /// <param name="GenJnlTemplate">Journal template record with filters that can be modified.</param>    [IntegrationEvent(false, false)]    local procedure OnOpenJnlBatchOnBeforeCheckGenJnlTemplateCount(var GenJnlBatch: Record "Gen. Journal Batch"; var GenJnlTemplate: Record "Gen. Journal Template")    begin    end;    /// <summary>    /// Integration event raised after balance calculation operations complete.    /// Enables custom processing or validation after balance calculations.    /// </summary>    /// <param name="GenJournalLine">Journal line record used for balance calculation context.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCalcBalance(var GenJournalLine: Record "Gen. Journal Line")    begin    end;    /// <summary>    /// Integration event raised after copying filters during balance calculation setup.    /// Enables custom filter modification before balance calculation processing.    /// </summary>    /// <param name="TempGenJournalLine">Temporary journal line record with copied filters that can be modified.</param>    [IntegrationEvent(false, false)]    local procedure OnCalcBalanceOnAfterCopyFilters(var TempGenJournalLine: Record "Gen. Journal Line" temporary)    begin    end;    /// <summary>    /// Integration event raised before moving to next record during balance calculation.    /// Enables custom record positioning logic during balance calculation.    /// </summary>    /// <param name="TempGenJournalLine">Temporary journal line record being positioned.</param>    [IntegrationEvent(false, false)]    local procedure OnCalcBalanceOnBeforeTempGenJnlLineNext(var TempGenJournalLine: Record "Gen. Journal Line")    begin    end;}