Table 232 Gen. Journal Batch

Base Application, Microsoft.Finance.GeneralLedger.Journal

src/Layers/W1/BaseApp/Finance/GeneralLedger/Journal/GenJournalBatch.Table.al620 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.Bank.Setup;using Microsoft.Finance.GeneralLedger.Account;using Microsoft.FixedAssets.FixedAsset;using Microsoft.Foundation.AuditCodes;using Microsoft.Foundation.NoSeries;using Microsoft.Intercompany.Partner;using Microsoft.Purchases.Vendor;using Microsoft.Sales.Customer;using System.Automation;/// <summary>/// Stores journal batch configurations that group journal lines for processing and provide default settings./// Batches inherit behavior from journal templates and enable organized transaction entry with shared defaults./// </summary>/// <remarks>/// Primary container for journal lines with batch-level validation and processing controls./// Key relationships: Links to Gen. Journal Template for configuration and Gen. Journal Line for transactions./// Extensibility: Supports approval workflows and batch-level customization through events and configuration fields./// </remarks>table 232 "Gen. Journal Batch"{    Caption = 'Gen. Journal Batch';    DataCaptionFields = Name, Description;    LookupPageID = "General Journal Batches";    DataClassification = CustomerContent;    fields    {        /// <summary>        /// References the journal template that defines behavior and configuration for this batch.        /// </summary>        field(1; "Journal Template Name"; Code[10])        {            Caption = 'Journal Template Name';            NotBlank = true;            TableRelation = "Gen. Journal Template";        }        /// <summary>        /// Unique identifier for the journal batch within the template scope.        /// </summary>        field(2; Name; Code[10])        {            Caption = 'Name';            ToolTip = 'Specifies the name of the journal you are creating.';            NotBlank = true;        }        /// <summary>        /// Descriptive name for the journal batch providing user-friendly identification.        /// </summary>        field(3; Description; Text[100])        {            Caption = 'Description';            ToolTip = 'Specifies a brief description of the journal batch you are creating.';        }        /// <summary>        /// Reason code applied to all journal lines in this batch for audit and reporting purposes.        /// </summary>        field(4; "Reason Code"; Code[10])        {            Caption = 'Reason Code';            ToolTip = 'Specifies the reason code, a supplementary source code that enables you to trace the entry.';            TableRelation = "Reason Code";            trigger OnValidate()            begin                if "Reason Code" <> xRec."Reason Code" then begin                    ModifyLines(FieldNo("Reason Code"));                    Modify();                end;            end;        }        /// <summary>        /// Default balancing account type applied to journal lines in this batch when no specific balancing account is specified.        /// </summary>        field(5; "Bal. Account Type"; Enum "Gen. Journal Account Type")        {            Caption = 'Bal. Account Type';            ToolTip = 'Specifies the type of account that a balancing entry is posted to, such as BANK for a cash account.';            trigger OnValidate()            begin                "Bal. Account No." := '';                Clear(BalAccountId);                if "Bal. Account Type" <> "Bal. Account Type"::"G/L Account" then                    "Bank Statement Import Format" := '';            end;        }        /// <summary>        /// Default balancing account number applied to journal lines when no specific balancing account is specified.        /// </summary>        field(6; "Bal. Account No."; Code[20])        {            Caption = 'Bal. Account No.';            ToolTip = 'Specifies the number of the general ledger, customer, vendor, or bank account that the balancing entry is posted to, such as a cash account for cash purchases.';            TableRelation = if ("Bal. Account Type" = const("G/L Account")) "G/L Account"            else            if ("Bal. Account Type" = const(Customer)) Customer            else            if ("Bal. Account Type" = const(Vendor)) Vendor            else            if ("Bal. Account Type" = const("Bank Account")) "Bank Account"            else            if ("Bal. Account Type" = const("Fixed Asset")) "Fixed Asset"            else            if ("Bal. Account Type" = const("IC Partner")) "IC Partner";            trigger OnValidate()            begin                if "Bal. Account Type" = "Bal. Account Type"::"G/L Account" then begin                    CheckGLAcc("Bal. Account No.");                    UpdateBalAccountId();                end;                CheckJnlIsNotRecurring();            end;        }        /// <summary>        /// Number series used for automatic document number assignment in journal lines within this batch.        /// </summary>        field(7; "No. Series"; Code[20])        {            Caption = 'No. Series';            ToolTip = 'Specifies the number series from which entry or record numbers are assigned to new entries or records.';            TableRelation = "No. Series";            trigger OnValidate()            var                IsHandled: Boolean;            begin                IsHandled := false;                OnBeforeNoSeriesValidate(Rec, IsHandled);                if IsHandled then                    exit;                if "No. Series" <> '' then begin                    GenJnlTemplate.Get("Journal Template Name");                    if GenJnlTemplate.Recurring then                        Error(                          Text000,                          FieldCaption("Posting No. Series"));                    if "No. Series" = "Posting No. Series" then                        Validate("Posting No. Series", '');                end;            end;        }        /// <summary>        /// Number series used for automatic posting document number assignment when journal lines are posted.        /// </summary>        field(8; "Posting No. Series"; Code[20])        {            Caption = 'Posting No. Series';            ToolTip = 'Specifies the code for the number series that will be used to assign document numbers to ledger entries that are posted from this journal batch.';            TableRelation = "No. Series";            trigger OnValidate()            begin                if ("Posting No. Series" = "No. Series") and ("Posting No. Series" <> '') then                    FieldError("Posting No. Series", StrSubstNo(Text001, "Posting No. Series"));                ModifyLines(FieldNo("Posting No. Series"));                Modify();            end;        }        /// <summary>        /// Controls automatic copying of VAT posting group setup from accounts to journal lines for VAT compliance.        /// </summary>        field(9; "Copy VAT Setup to Jnl. Lines"; Boolean)        {            Caption = 'Copy VAT Setup to Jnl. Lines';            ToolTip = 'Specifies whether the program to calculate VAT for accounts and balancing accounts on the journal line of the selected journal batch.';            InitValue = true;        }        /// <summary>        /// Enables VAT difference handling and manual VAT adjustments for journal lines in this batch.        /// </summary>        field(10; "Allow VAT Difference"; Boolean)        {            Caption = 'Allow VAT Difference';            ToolTip = 'Specifies whether to allow the manual adjustment of VAT amounts in journal templates.';            trigger OnValidate()            begin                if "Allow VAT Difference" then begin                    GenJnlTemplate.Get("Journal Template Name");                    GenJnlTemplate.TestField("Allow VAT Difference", true);                end;            end;        }        /// <summary>        /// Controls whether journal lines in this batch can be exported for electronic payment processing.        /// </summary>        field(11; "Allow Payment Export"; Boolean)        {            Caption = 'Allow Payment Export';            ToolTip = 'Specifies if you can export bank payment files from payment journal lines using this general journal batch.';        }        /// <summary>        /// Specifies the import format used for processing bank statements related to this journal batch.        /// </summary>        field(12; "Bank Statement Import Format"; Code[20])        {            Caption = 'Bank Statement Import Format';            ToolTip = 'Specifies the format of the bank statement file that can be imported into this general journal batch.';            TableRelation = "Bank Export/Import Setup".Code where(Direction = const(Import));            trigger OnValidate()            begin                if ("Bank Statement Import Format" <> '') and ("Bal. Account Type" <> "Bal. Account Type"::"G/L Account") then                    FieldError("Bank Statement Import Format", BankStmtImpFormatBalAccErr);            end;        }        /// <summary>        /// Journal template type inherited from the associated journal template for workflow and validation control.        /// </summary>        field(21; "Template Type"; Enum "Gen. Journal Template Type")        {            CalcFormula = lookup("Gen. Journal Template".Type where(Name = field("Journal Template Name")));            Caption = 'Template Type';            Editable = false;            FieldClass = FlowField;        }        /// <summary>        /// Indicates whether this journal batch supports recurring journal entries with automatic regeneration capabilities.        /// </summary>        field(22; Recurring; Boolean)        {            CalcFormula = lookup("Gen. Journal Template".Recurring where(Name = field("Journal Template Name")));            Caption = 'Recurring';            Editable = false;            FieldClass = FlowField;        }        /// <summary>        /// Controls whether the system automatically suggests balancing amounts when creating journal lines in this batch.        /// </summary>        field(23; "Suggest Balancing Amount"; Boolean)        {            Caption = 'Suggest Balancing Amount';            ToolTip = 'Specifies if the Amount field on journal lines for the same document number is automatically prefilled with the value that is required to balance the document.';        }        /// <summary>        /// Indicates whether this journal batch is currently pending approval in the approval workflow system.        /// </summary>        field(28; "Pending Approval"; Boolean)        {            Caption = 'Pending Approval';            Editable = false;        }        /// <summary>        /// Controls whether posted journal entries are automatically copied to posted journal lines for archival and audit purposes.        /// </summary>        field(31; "Copy to Posted Jnl. Lines"; Boolean)        {            Caption = 'Copy to Posted Jnl. Lines';            ToolTip = 'Specifies whether the journal lines to be copied to posted journal lines of the selected journal batch.';            trigger OnValidate()            begin                if "Copy to Posted Jnl. Lines" then begin                    GenJnlTemplate.Get("Journal Template Name");                    GenJnlTemplate.TestField("Copy to Posted Jnl. Lines", true);                end;            end;        }        field(40; "No. of Lines"; Integer)        {            CalcFormula = count("Gen. Journal Line" where("Journal Template Name" = field("Journal Template Name"), "Journal Batch Name" = field(Name)));            Caption = 'No. of Lines';            Editable = false;            FieldClass = FlowField;            ToolTip = 'Specifies the number of lines in this journal batch.';        }        /// <summary>        /// System-maintained timestamp indicating when this journal batch was last modified for change tracking.        /// </summary>        field(8001; "Last Modified DateTime"; DateTime)        {            Caption = 'Last Modified DateTime';        }        /// <summary>        /// System identifier linking this batch to the associated G/L Account for API integration and balancing account resolution.        /// </summary>        field(8002; BalAccountId; Guid)        {            Caption = 'BalAccountId';            DataClassification = SystemMetadata;            trigger OnValidate()            var                GLAccount: Record "G/L Account";            begin                if not IsNullGuid(BalAccountId) then begin                    if not GLAccount.GetBySystemId(BalAccountId) then                        Error(BalAccountIdDoesNotMatchAGLAccountErr);                    CheckGLAcc(GLAccount."No.");                end;                Validate("Bal. Account Type", "Bal. Account Type"::"G/L Account");                Validate("Bal. Account No.", GLAccount."No.");            end;        }    }    keys    {        key(Key1; "Journal Template Name", Name)        {            Clustered = true;        }    }    fieldgroups    {        fieldgroup(Brick; Name, "Journal Template Name", Description, "Bal. Account Type", "Bal. Account No.")        {        }    }    trigger OnDelete()    begin        ApprovalsMgmt.PreventDeletingRecordWithOpenApprovalEntry(Rec);        GenJnlAlloc.SetRange("Journal Template Name", "Journal Template Name");        GenJnlAlloc.SetRange("Journal Batch Name", Name);        GenJnlAlloc.DeleteAll();        GenJnlLine.SetRange("Journal Template Name", "Journal Template Name");        GenJnlLine.SetRange("Journal Batch Name", Name);        GenJnlLine.DeleteAll(true);    end;    trigger OnInsert()    begin        LockTable();        GenJnlTemplate.Get("Journal Template Name");        if not GenJnlTemplate."Copy VAT Setup to Jnl. Lines" then            "Copy VAT Setup to Jnl. Lines" := false;        "Allow Payment Export" := GenJnlTemplate.Type = GenJnlTemplate.Type::Payments;        SetLastModifiedDateTime();    end;    trigger OnModify()    begin        ApprovalsMgmt.PreventModifyRecIfOpenApprovalEntryExistForCurrentUser(Rec);        SetLastModifiedDateTime();    end;    trigger OnRename()    begin        ApprovalsMgmt.OnRenameRecordInApprovalRequest(xRec.RecordId, RecordId);        SetLastModifiedDateTime();    end;    var        GenJnlTemplate: Record "Gen. Journal Template";        GenJnlLine: Record "Gen. Journal Line";        GenJnlAlloc: Record "Gen. Jnl. Allocation";        ApprovalsMgmt: Codeunit "Approvals Mgmt.";#pragma warning disable AA0074#pragma warning disable AA0470        Text000: Label 'Only the %1 field can be filled in on recurring journals.';        Text001: Label 'must not be %1';#pragma warning restore AA0470#pragma warning restore AA0074        BankStmtImpFormatBalAccErr: Label 'must be blank. When Bal. Account Type = Bank Account, then Bank Statement Import Format on the Bank Account card will be used', Comment = 'FIELDERROR ex: Bank Statement Import Format must be blank. When Bal. Account Type = Bank Account, then Bank Statement Import Format on the Bank Account card will be used in Gen. Journal Batch Journal Template Name=''GENERAL'',Name=''CASH''.';        CannotBeSpecifiedForRecurrJnlErr: Label 'cannot be specified when using recurring journals';        BalAccountIdDoesNotMatchAGLAccountErr: Label 'The "balancingAccountNumber" does not match to a G/L Account.', Locked = true;    /// <summary>    /// Sets up a new journal batch with default values from the journal template.    /// Copies configuration settings like balancing account, number series, and reason codes from the template.    /// </summary>    procedure SetupNewBatch()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetupNewBatch(Rec, IsHandled);        if IsHandled then            exit;        GenJnlTemplate.Get("Journal Template Name");        "Bal. Account Type" := GenJnlTemplate."Bal. Account Type";        "Bal. Account No." := GenJnlTemplate."Bal. Account No.";        "No. Series" := GenJnlTemplate."No. Series";        "Posting No. Series" := GenJnlTemplate."Posting No. Series";        "Reason Code" := GenJnlTemplate."Reason Code";        "Copy VAT Setup to Jnl. Lines" := GenJnlTemplate."Copy VAT Setup to Jnl. Lines";        "Allow VAT Difference" := GenJnlTemplate."Allow VAT Difference";        "Copy to Posted Jnl. Lines" := GenJnlTemplate."Copy to Posted Jnl. Lines";        OnAfterSetupNewBatch(Rec);    end;    local procedure CheckGLAcc(AccNo: Code[20])    var        GLAcc: Record "G/L Account";    begin        if AccNo <> '' then begin            GLAcc.Get(AccNo);            GLAcc.CheckGLAcc();            GLAcc.TestField("Direct Posting", true);        end;    end;    local procedure CheckJnlIsNotRecurring()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckJnlIsNotRecurring(Rec, IsHandled);        if IsHandled then            exit;        if "Bal. Account No." = '' then            exit;        GenJnlTemplate.Get("Journal Template Name");        if GenJnlTemplate.Recurring then            FieldError("Bal. Account No.", CannotBeSpecifiedForRecurrJnlErr);    end;    local procedure ModifyLines(i: Integer)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeModifyLines(Rec, i, IsHandled);        if IsHandled then            exit;        GenJnlLine.LockTable();        GenJnlLine.SetRange("Journal Template Name", "Journal Template Name");        GenJnlLine.SetRange("Journal Batch Name", Name);        if GenJnlLine.Find('-') then            repeat                case i of                    FieldNo("Reason Code"):                        GenJnlLine.Validate("Reason Code", "Reason Code");                    FieldNo("Posting No. Series"):                        GenJnlLine.Validate("Posting No. Series", "Posting No. Series");                end;                GenJnlLine.Modify(true);            until GenJnlLine.Next() = 0;    end;    /// <summary>    /// Checks whether any journal lines exist for this journal batch.    /// Used for validation before allowing batch deletion or modification.    /// </summary>    /// <returns>True if journal lines exist for this batch, false otherwise.</returns>    procedure LinesExist(): Boolean    var        GenJournalLine: Record "Gen. Journal Line";    begin        GenJournalLine.SetRange("Journal Template Name", "Journal Template Name");        GenJournalLine.SetRange("Journal Batch Name", Name);        exit(not GenJournalLine.IsEmpty);    end;    /// <summary>    /// Calculates the total balance of all journal lines in this batch.    /// Returns the sum of Balance (LCY) field for all lines in the batch.    /// </summary>    /// <returns>The total balance of all journal lines in local currency.</returns>    procedure GetBalance(): Decimal    var        GenJournalLine: Record "Gen. Journal Line";    begin        GenJournalLine.SetRange("Journal Template Name", "Journal Template Name");        GenJournalLine.SetRange("Journal Batch Name", Name);        OnGetBalanceOnAfterSetGenJournalLineFilters(GenJournalLine);        GenJournalLine.CalcSums("Balance (LCY)");        exit(GenJournalLine."Balance (LCY)");    end;    /// <summary>    /// Checks the balance of the journal batch and triggers appropriate events.    /// Calls OnGeneralJournalBatchBalanced if balanced, OnGeneralJournalBatchNotBalanced if not.    /// </summary>    /// <returns>The current balance of the journal batch in local currency.</returns>    procedure CheckBalance() Balance: Decimal    begin        Balance := GetBalance();        if Balance = 0 then            OnGeneralJournalBatchBalanced()        else            OnGeneralJournalBatchNotBalanced();    end;    /// <summary>    /// Integration event that occurs when a general journal batch is balanced (total balance equals zero).    /// Allows customization of behavior when journal batches achieve balance validation.    /// </summary>    [IntegrationEvent(true, false)]    local procedure OnGeneralJournalBatchBalanced()    begin    end;    /// <summary>    /// Integration event that occurs when a general journal batch is not balanced (total balance is not zero).    /// Allows customization of error handling or warnings when journal batches fail balance validation.    /// </summary>    [IntegrationEvent(true, false)]    local procedure OnGeneralJournalBatchNotBalanced()    begin    end;    [IntegrationEvent(true, false)]    [Scope('OnPrem')]    procedure OnCheckGenJournalLineExportRestrictions()    begin    end;    [IntegrationEvent(true, false)]    [Scope('OnPrem')]    procedure OnMoveGenJournalBatch(ToRecordID: RecordID)    begin    end;    local procedure SetLastModifiedDateTime()    begin        "Last Modified DateTime" := CurrentDateTime;    end;    /// <summary>    /// Updates the Bal. Account Id field based on the current balancing account number and type.    /// Synchronizes the system ID field with the referenced G/L Account record.    /// </summary>    procedure UpdateBalAccountId()    var        GLAccount: Record "G/L Account";    begin        if "Bal. Account No." = '' then begin            Clear(BalAccountId);            exit;        end;        if not GLAccount.Get("Bal. Account No.") then            exit;        BalAccountId := GLAccount.SystemId;    end;    /// <summary>    /// Integration event raised after setting up a new journal batch with default configuration.    /// Enables custom initialization of batch settings and default values.    /// </summary>    /// <param name="GenJnlBatch">Newly created journal batch for customization</param>    [IntegrationEvent(false, false)]    local procedure OnAfterSetupNewBatch(var GenJnlBatch: Record "Gen. Journal Batch")    begin    end;    /// <summary>    /// Integration event raised before checking if journal batch is not recurring type.    /// Enables custom validation logic for recurring journal restrictions.    /// </summary>    /// <param name="GenJournalBatch">Journal batch to validate for recurring type</param>    /// <param name="IsHandled">Set to true to skip standard recurring journal validation</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckJnlIsNotRecurring(var GenJournalBatch: Record "Gen. Journal Batch"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before modifying journal lines when batch settings change.    /// Enables custom handling of line updates during batch modification.    /// </summary>    /// <param name="GenJournalBatch">Journal batch being modified</param>    /// <param name="i">Iterator value during batch processing</param>    /// <param name="IsHandled">Set to true to skip standard line modification logic</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeModifyLines(var GenJournalBatch: Record "Gen. Journal Batch"; i: Integer; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before validating number series assignment on journal batch.    /// Enables custom number series validation logic and assignment rules.    /// </summary>    /// <param name="GenJournalBatch">Journal batch with number series to validate</param>    /// <param name="IsHandled">Set to true to skip standard number series validation</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeNoSeriesValidate(var GenJournalBatch: Record "Gen. Journal Batch"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before setting up a new journal batch configuration.    /// Enables custom batch creation logic and default value assignment.    /// </summary>    /// <param name="GenJournalBatch">Journal batch being set up</param>    /// <param name="IsHandled">Set to true to skip standard batch setup logic</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeSetupNewBatch(GenJournalBatch: Record "Gen. Journal Batch"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised after setting filters on journal lines during balance calculation.    /// Enables additional filtering criteria for balance computation.    /// </summary>    /// <param name="GenJournalLine">Journal line record with applied filters for balance calculation</param>    [IntegrationEvent(false, false)]    local procedure OnGetBalanceOnAfterSetGenJournalLineFilters(var GenJournalLine: Record "Gen. Journal Line")    begin    end;}