Table 232 Gen. Journal Batch
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;}