Table 221 Gen. Jnl. Allocation
src/Layers/W1/BaseApp/Finance/GeneralLedger/Journal/GenJnlAllocation.Table.al1,027 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.Finance.AllocationAccount;using Microsoft.Finance.Currency;using Microsoft.Finance.Dimension;using Microsoft.Finance.GeneralLedger.Account;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Finance.SalesTax;using Microsoft.Finance.VAT.Setup;using Microsoft.Foundation.Enums;using System.Utilities;/// <summary>/// Table for storing allocation lines that distribute general journal line amounts across multiple G/L accounts./// Enables splitting journal line amounts using percentages, amounts, or quantities for cost allocation and distribution./// </summary>/// <remarks>/// Core allocation functionality for general journal lines enabling multi-account distribution./// Supports percentage-based, amount-based, and quantity-based allocation methods./// Key fields: Account No., Allocation %, Amount, VAT handling for proper tax distribution./// Integration: Links to parent journal line via template, batch, and line number references./// </remarks>table 221 "Gen. Jnl. Allocation"{ Caption = 'Gen. Jnl. Allocation'; Permissions = tabledata "Gen. Jnl. Allocation" = R; DataClassification = CustomerContent; fields { /// <summary> /// Journal template name that defines the type and behavior of the journal containing this allocation line. /// </summary> field(1; "Journal Template Name"; Code[10]) { Caption = 'Journal Template Name'; TableRelation = "Gen. Journal Template"; } /// <summary> /// Journal batch name that groups related journal lines for this allocation. /// </summary> field(2; "Journal Batch Name"; Code[10]) { Caption = 'Journal Batch Name'; TableRelation = "Gen. Journal Batch".Name where("Journal Template Name" = field("Journal Template Name")); } /// <summary> /// Line number of the parent general journal line to which this allocation applies. /// </summary> field(3; "Journal Line No."; Integer) { Caption = 'Journal Line No.'; TableRelation = "Gen. Journal Line"."Line No." where("Journal Template Name" = field("Journal Template Name"), "Journal Batch Name" = field("Journal Batch Name")); } /// <summary> /// Sequential line number for this allocation entry within the parent journal line. /// </summary> field(4; "Line No."; Integer) { Caption = 'Line No.'; } /// <summary> /// G/L account number to which the allocated amount will be posted. /// </summary> field(5; "Account No."; Code[20]) { Caption = 'Account No.'; ToolTip = 'Specifies the account number that the allocation will be posted to.'; TableRelation = "G/L Account"; trigger OnValidate() var IsHandled: Boolean; begin IsHandled := false; OnBeforeValidateAccountNo(Rec, xRec, IsHandled); if IsHandled then exit; if "Account No." = '' then begin GLAcc.Init(); CreateDimFromDefaultDim(); end else begin GLAcc.Get("Account No."); GLAcc.CheckGLAcc(); CheckGLAccount(GLAcc); end; "Account Name" := GLAcc.Name; if CopyVATSetupToJnlLines() then begin "Gen. Posting Type" := GLAcc."Gen. Posting Type"; "Gen. Bus. Posting Group" := GLAcc."Gen. Bus. Posting Group"; "Gen. Prod. Posting Group" := GLAcc."Gen. Prod. Posting Group"; "VAT Bus. Posting Group" := GLAcc."VAT Bus. Posting Group"; "VAT Prod. Posting Group" := GLAcc."VAT Prod. Posting Group"; Validate("VAT Prod. Posting Group"); end; CreateDimFromDefaultDim(); end; } /// <summary> /// First shortcut dimension code for this allocation line, typically used for department or project classification. /// </summary> field(6; "Shortcut Dimension 1 Code"; Code[20]) { CaptionClass = '1,2,1'; Caption = 'Shortcut Dimension 1 Code'; ToolTip = 'Specifies the code for Shortcut Dimension 1, which is one of two global dimension codes that you set up in the General Ledger Setup window.'; TableRelation = "Dimension Value".Code where("Global Dimension No." = const(1), Blocked = const(false)); trigger OnValidate() begin Rec.ValidateShortcutDimCode(1, "Shortcut Dimension 1 Code"); Modify(); end; } /// <summary> /// Second shortcut dimension code for this allocation line, typically used for cost center or area classification. /// </summary> field(7; "Shortcut Dimension 2 Code"; Code[20]) { CaptionClass = '1,2,2'; Caption = 'Shortcut Dimension 2 Code'; ToolTip = 'Specifies the code for Shortcut Dimension 2, which is one of two global dimension codes that you set up in the General Ledger Setup window.'; TableRelation = "Dimension Value".Code where("Global Dimension No." = const(2), Blocked = const(false)); trigger OnValidate() begin Rec.ValidateShortcutDimCode(2, "Shortcut Dimension 2 Code"); Modify(); end; } /// <summary> /// Allocation quantity used for quantity-based distribution of journal line amounts. /// When specified, amounts are distributed proportionally based on quantities rather than percentages. /// </summary> field(8; "Allocation Quantity"; Decimal) { Caption = 'Allocation Quantity'; ToolTip = 'Specifies the quantity that will be used to calculate the amount in the allocation journal line.'; DecimalPlaces = 0 : 5; AutoFormatType = 0; trigger OnValidate() begin if "Allocation Quantity" = 0 then begin "Allocation %" := 0; Amount := 0; end; UpdateAllocations(GenJnlLine); GenJnlLine.UpdateLineBalance(); end; } /// <summary> /// Percentage of the parent journal line amount to allocate to this account. /// Used for percentage-based distribution where total percentages across allocation lines should equal 100%. /// </summary> field(9; "Allocation %"; Decimal) { Caption = 'Allocation %'; ToolTip = 'Specifies the percentage that will be used to calculate the amount in the allocation journal line.'; DecimalPlaces = 2 : 2; AutoFormatType = 0; trigger OnValidate() begin "Allocation Quantity" := 0; if "Allocation %" = 0 then Amount := 0; UpdateAllocations(GenJnlLine); GenJnlLine.UpdateLineBalance(); end; } /// <summary> /// Fixed allocation amount to be posted to this account. /// Used for amount-based distribution where specific amounts are allocated rather than percentages or quantities. /// </summary> field(10; Amount; Decimal) { AutoFormatExpression = GetCurrencyCode(); AutoFormatType = 1; Caption = 'Amount'; ToolTip = 'Specifies the amount that will be posted from the allocation journal line.'; trigger OnValidate() begin if ("Allocation Quantity" <> 0) or ("Allocation %" <> 0) then begin "Allocation Quantity" := 0; "Allocation %" := 0; UpdateAllocations(GenJnlLine); end else begin Validate("VAT Prod. Posting Group"); Modify(); GenJnlLine.UpdateLineBalance(); UpdateJnlBalance(GenJnlLine); end; end; } /// <summary> /// General posting type that determines how this allocation line affects general ledger posting. /// Controls whether the allocation creates purchase, sale, or other general ledger entries. /// </summary> field(11; "Gen. Posting Type"; Enum "General Posting Type") { Caption = 'Gen. Posting Type'; ToolTip = 'Specifies the type of transaction.'; trigger OnValidate() begin Validate("VAT Prod. Posting Group"); end; } /// <summary> /// General business posting group used for determining posting accounts and VAT treatment for this allocation line. /// Links to general posting setup for proper account determination during posting. /// </summary> field(12; "Gen. Bus. Posting Group"; Code[20]) { Caption = 'Gen. Bus. Posting Group'; ToolTip = 'Specifies the vendor''s or customer''s trade type to link transactions made for this business partner with the appropriate general ledger account according to the general posting setup.'; TableRelation = "Gen. Business Posting Group"; trigger OnValidate() begin if xRec."Gen. Bus. Posting Group" <> "Gen. Bus. Posting Group" then if GenBusPostingGrp.ValidateVatBusPostingGroup(GenBusPostingGrp, "Gen. Bus. Posting Group") then Validate("VAT Bus. Posting Group", GenBusPostingGrp."Def. VAT Bus. Posting Group"); end; } /// <summary> /// General product posting group used for determining posting accounts and VAT treatment for this allocation line. /// Links to general posting setup for proper account determination during posting. /// </summary> field(13; "Gen. Prod. Posting Group"; Code[20]) { Caption = 'Gen. Prod. Posting Group'; ToolTip = 'Specifies the item''s product type to link transactions made for this item with the appropriate general ledger account according to the general posting setup.'; TableRelation = "Gen. Product Posting Group"; trigger OnValidate() begin if xRec."Gen. Prod. Posting Group" <> "Gen. Prod. Posting Group" then if GenProdPostingGrp.ValidateVatProdPostingGroup(GenProdPostingGrp, "Gen. Prod. Posting Group") then Validate("VAT Prod. Posting Group", GenProdPostingGrp."Def. VAT Prod. Posting Group"); end; } /// <summary> /// VAT calculation method used for this allocation line to determine VAT amount computation. /// </summary> field(14; "VAT Calculation Type"; Enum "Tax Calculation Type") { Caption = 'VAT Calculation Type'; Editable = false; } /// <summary> /// VAT amount calculated for this allocation line based on the allocation amount and VAT percentage. /// </summary> field(15; "VAT Amount"; Decimal) { AutoFormatExpression = GetCurrencyCode(); AutoFormatType = 1; Caption = 'VAT Amount'; Editable = false; } /// <summary> /// VAT percentage rate applied to this allocation line for VAT amount calculation. /// </summary> field(16; "VAT %"; Decimal) { Caption = 'VAT %'; DecimalPlaces = 0 : 5; Editable = false; MaxValue = 100; MinValue = 0; AutoFormatType = 0; } /// <summary> /// Name of the G/L account specified for this allocation line, automatically populated when Account No. is selected. /// </summary> field(17; "Account Name"; Text[100]) { CalcFormula = lookup("G/L Account".Name where("No." = field("Account No."))); Caption = 'Account Name'; ToolTip = 'Specifies the name of the account that the allocation will be posted to.'; Editable = false; FieldClass = FlowField; } /// <summary> /// Tax area code for sales tax calculation when tax functionality is enabled for this allocation line. /// </summary> field(18; "Tax Area Code"; Code[20]) { Caption = 'Tax Area Code'; TableRelation = "Tax Area"; trigger OnValidate() begin Validate("VAT Prod. Posting Group"); end; } /// <summary> /// Indicates whether this allocation line is subject to sales tax liability when tax functionality is enabled. /// </summary> field(19; "Tax Liable"; Boolean) { Caption = 'Tax Liable'; trigger OnValidate() begin Validate("VAT Prod. Posting Group"); end; } /// <summary> /// Tax group code for sales tax calculation when tax functionality is enabled for this allocation line. /// </summary> field(20; "Tax Group Code"; Code[20]) { Caption = 'Tax Group Code'; TableRelation = "Tax Group"; trigger OnValidate() begin Validate("VAT Prod. Posting Group"); end; } /// <summary> /// Indicates whether this allocation line uses reverse charge VAT (use tax) when tax functionality is enabled. /// </summary> field(21; "Use Tax"; Boolean) { Caption = 'Use Tax'; trigger OnValidate() begin Validate("VAT Prod. Posting Group"); end; } /// <summary> /// VAT business posting group code for VAT calculation setup applicable to this allocation line. /// </summary> field(22; "VAT Bus. Posting Group"; Code[20]) { Caption = 'VAT Bus. Posting Group'; ToolTip = 'Specifies the VAT specification of the involved customer or vendor to link transactions made for this record with the appropriate general ledger account according to the VAT posting setup.'; TableRelation = "VAT Business Posting Group"; trigger OnValidate() begin Validate("VAT Prod. Posting Group"); end; } /// <summary> /// VAT product posting group code for VAT calculation setup applicable to this allocation line. /// </summary> field(23; "VAT Prod. Posting Group"; Code[20]) { Caption = 'VAT Prod. Posting Group'; ToolTip = 'Specifies the VAT specification of the involved item or resource to link transactions made for this record with the appropriate general ledger account according to the VAT posting setup.'; TableRelation = "VAT Product Posting Group"; trigger OnValidate() begin GenJnlLine.Get("Journal Template Name", "Journal Batch Name", "Journal Line No."); CheckVAT(GenJnlLine); UpdateVAT(GenJnlLine); end; } /// <summary> /// Allocation amount expressed in the additional reporting currency when ACY functionality is enabled. /// </summary> field(24; "Additional-Currency Amount"; Decimal) { AutoFormatType = 1; Caption = 'Additional-Currency Amount'; Editable = false; AutoFormatExpression = GetAdditionalReportingCurrencyCode(); } /// <summary> /// Unique identifier for the dimension set associated with this allocation line for financial analysis and reporting. /// </summary> field(480; "Dimension Set ID"; Integer) { Caption = 'Dimension Set ID'; Editable = false; TableRelation = "Dimension Set Entry"; trigger OnLookup() begin Rec.ShowDimensions(); end; trigger OnValidate() begin DimMgt.UpdateGlobalDimFromDimSetID("Dimension Set ID", "Shortcut Dimension 1 Code", "Shortcut Dimension 2 Code"); end; } } keys { key(Key1; "Journal Template Name", "Journal Batch Name", "Journal Line No.", "Line No.") { Clustered = true; } } fieldgroups { } trigger OnDelete() begin Validate(Amount, 0); end; trigger OnInsert() begin LockTable(); GenJnlLine.Get("Journal Template Name", "Journal Batch Name", "Journal Line No."); Rec.ValidateShortcutDimCode(1, "Shortcut Dimension 1 Code"); Rec.ValidateShortcutDimCode(2, "Shortcut Dimension 2 Code"); end; var GLAcc: Record "G/L Account"; GenJnlLine: Record "Gen. Journal Line"; GenBusPostingGrp: Record "Gen. Business Posting Group"; GenProdPostingGrp: Record "Gen. Product Posting Group"; DimMgt: Codeunit DimensionManagement; AllocAccountImportWrongAccTypeErr: Label 'Import from Allocation Account is only allowed for G/L Account Destination account type.'; ImportDeletesExistingLinesQst: Label 'Importing from Allocation Account will delete all existing allocations. Do you want to continue?';#pragma warning disable AA0074#pragma warning disable AA0470 Text000: Label '%1 cannot be used in allocations when they are completed on the general journal line.';#pragma warning restore AA0470#pragma warning restore AA0074 protected procedure CopyVATSetupToJnlLines(): Boolean var GenJournalBatch: Record "Gen. Journal Batch"; begin if ("Journal Template Name" <> '') and ("Journal Batch Name" <> '') then if GenJournalBatch.Get(Rec."Journal Template Name", Rec."Journal Batch Name") then exit(GenJournalBatch."Copy VAT Setup to Jnl. Lines"); exit(true); end; /// <summary> /// Updates allocation amounts and distributions for all allocation lines associated with the specified journal line. /// Recalculates allocation percentages and amounts to ensure total allocation equals journal line amount. /// </summary> /// <param name="GenJnlLine">General journal line record for which allocations should be updated.</param> procedure UpdateAllocations(var GenJnlLine: Record "Gen. Journal Line") var GenJnlAlloc: Record "Gen. Jnl. Allocation"; GenJnlAlloc2: Record "Gen. Jnl. Allocation"; FromAllocations: Boolean; TotalQty: Decimal; TotalPct: Decimal; TotalPctRnded: Decimal; TotalAmountLCY: Decimal; TotalAmountLCY2: Decimal; TotalAmountLCYRnded: Decimal; TotalAmountLCYRnded2: Decimal; UpdateGenJnlLine: Boolean; begin TotalQty := 0; TotalPct := 0; TotalPctRnded := 0; TotalAmountLCYRnded := 0; TotalAmountLCYRnded2 := 0; if "Line No." <> 0 then begin FromAllocations := true; GenJnlAlloc.UpdateVAT(GenJnlLine); Modify(); GenJnlLine.Get("Journal Template Name", "Journal Batch Name", "Journal Line No."); CheckVAT(GenJnlLine); end; GenJnlAlloc.SetRange("Journal Template Name", GenJnlLine."Journal Template Name"); GenJnlAlloc.SetRange("Journal Batch Name", GenJnlLine."Journal Batch Name"); GenJnlAlloc.SetRange("Journal Line No.", GenJnlLine."Line No."); if FromAllocations then UpdateGenJnlLine := true else if not GenJnlAlloc.IsEmpty() then begin GenJnlAlloc.LockTable(); UpdateGenJnlLine := true; end; if GenJnlAlloc.FindSet() then repeat if (GenJnlAlloc."Allocation Quantity" <> 0) or (GenJnlAlloc."Allocation %" <> 0) then begin if not FromAllocations then GenJnlAlloc.CheckVAT(GenJnlLine); if GenJnlAlloc."Allocation Quantity" = 0 then begin TotalAmountLCY2 := TotalAmountLCY2 - GenJnlLine."Amount (LCY)" * GenJnlAlloc."Allocation %" / 100; GenJnlAlloc.Amount := Round(TotalAmountLCY2) - TotalAmountLCYRnded2; TotalAmountLCYRnded2 := TotalAmountLCYRnded2 + GenJnlAlloc.Amount; end else begin if TotalQty = 0 then begin GenJnlAlloc2.Copy(GenJnlAlloc); GenJnlAlloc2.SetFilter("Allocation Quantity", '<>0'); GenJnlAlloc2.CalcSums("Allocation Quantity"); TotalQty := GenJnlAlloc2."Allocation Quantity"; if TotalQty = 0 then TotalQty := 1; end; TotalPct := TotalPct + GenJnlAlloc."Allocation Quantity" / TotalQty * 100; GenJnlAlloc."Allocation %" := Round(TotalPct, 0.01) - TotalPctRnded; TotalPctRnded := TotalPctRnded + GenJnlAlloc."Allocation %"; TotalAmountLCY := TotalAmountLCY - GenJnlLine."Amount (LCY)" * GenJnlAlloc."Allocation Quantity" / TotalQty; GenJnlAlloc.Amount := Round(TotalAmountLCY) - TotalAmountLCYRnded; TotalAmountLCYRnded := TotalAmountLCYRnded + GenJnlAlloc.Amount; end; GenJnlAlloc.UpdateVAT(GenJnlLine); OnUpdateAllocationsOnBeforeGenJnlAllocModify(GenJnlLine, GenJnlAlloc); GenJnlAlloc.Modify(); OnUpdateAllocationsOnAfterGenJnlAllocModify(GenJnlAlloc); end; until GenJnlAlloc.Next() = 0; if UpdateGenJnlLine then UpdateJnlBalance(GenJnlLine); if FromAllocations then Find(); end; /// <summary> /// Updates allocation amounts in additional reporting currency for all allocation lines associated with the specified journal line. /// Converts allocation amounts to additional currency using current exchange rates. /// </summary> /// <param name="GenJnlLine">General journal line record for which additional currency allocations should be updated.</param> /// <param name="AddCurrAmount">Total additional currency amount to distribute across allocation lines.</param> procedure UpdateAllocationsAddCurr(var GenJnlLine: Record "Gen. Journal Line"; AddCurrAmount: Decimal) var GenJnlAlloc: Record "Gen. Jnl. Allocation"; GenJnlAlloc2: Record "Gen. Jnl. Allocation"; GLSetup: Record "General Ledger Setup"; Currency: Record Currency; TotalQty: Decimal; TotalPct: Decimal; TotalPctRnded: Decimal; TotalAmountAddCurr: Decimal; TotalAmountAddCurr2: Decimal; TotalAmountAddCurrRnded: Decimal; TotalAmountAddCurrRnded2: Decimal; begin TotalQty := 0; TotalPct := 0; TotalPctRnded := 0; TotalAmountAddCurr := 0; TotalAmountAddCurr2 := 0; TotalAmountAddCurrRnded := 0; TotalAmountAddCurrRnded2 := 0; GenJnlAlloc.SetRange("Journal Template Name", GenJnlLine."Journal Template Name"); GenJnlAlloc.SetRange("Journal Batch Name", GenJnlLine."Journal Batch Name"); GenJnlAlloc.SetRange("Journal Line No.", GenJnlLine."Line No."); GenJnlAlloc.LockTable(); if GenJnlAlloc.FindSet() then begin GLSetup.Get(); Currency.Get(GLSetup."Additional Reporting Currency"); Currency.TestField("Amount Rounding Precision"); repeat if (GenJnlAlloc."Allocation Quantity" <> 0) or (GenJnlAlloc."Allocation %" <> 0) then begin if GenJnlAlloc."Allocation Quantity" = 0 then begin TotalAmountAddCurr2 := TotalAmountAddCurr2 - AddCurrAmount * GenJnlAlloc."Allocation %" / 100; GenJnlAlloc."Additional-Currency Amount" := Round(TotalAmountAddCurr2, Currency."Amount Rounding Precision") - TotalAmountAddCurrRnded2; TotalAmountAddCurrRnded2 := TotalAmountAddCurrRnded2 + GenJnlAlloc."Additional-Currency Amount"; end else begin if TotalQty = 0 then begin GenJnlAlloc2.Copy(GenJnlAlloc); GenJnlAlloc2.SetFilter("Allocation Quantity", '<>0'); repeat TotalQty := TotalQty + GenJnlAlloc2."Allocation Quantity"; until GenJnlAlloc2.Next() = 0; if TotalQty = 0 then TotalQty := 1; end; TotalPct := TotalPct + GenJnlAlloc."Allocation Quantity" / TotalQty * 100; GenJnlAlloc."Allocation %" := Round(TotalPct, 0.01) - TotalPctRnded; TotalPctRnded := TotalPctRnded + GenJnlAlloc."Allocation %"; TotalAmountAddCurr := TotalAmountAddCurr - AddCurrAmount * GenJnlAlloc."Allocation Quantity" / TotalQty; GenJnlAlloc."Additional-Currency Amount" := Round(TotalAmountAddCurr, Currency."Amount Rounding Precision") - TotalAmountAddCurrRnded; TotalAmountAddCurrRnded := TotalAmountAddCurrRnded + GenJnlAlloc."Additional-Currency Amount"; end; GenJnlAlloc.Modify(); OnUpdateAllocationsAddCurrOnAfterGenJnlAllocModify(GenJnlAlloc); end; until GenJnlAlloc.Next() = 0; end; end; local procedure UpdateJnlBalance(var GenJnlLine: Record "Gen. Journal Line") begin GenJnlLine.CalcFields("Allocated Amt. (LCY)"); if GenJnlLine."Bal. Account No." = '' then GenJnlLine."Balance (LCY)" := GenJnlLine."Amount (LCY)" + GenJnlLine."Allocated Amt. (LCY)" else GenJnlLine."Balance (LCY)" := GenJnlLine."Allocated Amt. (LCY)"; GenJnlLine.Modify(); end; /// <summary> /// Validates VAT setup and calculations for this allocation line based on the associated journal line context. /// Ensures VAT posting groups and calculation types are compatible with journal line requirements. /// </summary> /// <param name="GenJnlLine">General journal line record providing VAT validation context for this allocation.</param> procedure CheckVAT(var GenJnlLine: Record "Gen. Journal Line") begin if ("Gen. Posting Type" <> "Gen. Posting Type"::" ") and (GenJnlLine."Gen. Posting Type" <> GenJnlLine."Gen. Posting Type"::" ") then Error( Text000, GenJnlLine.FieldCaption("Gen. Posting Type")); end; /// <summary> /// Updates VAT amounts and percentages for this allocation line based on current VAT setup and allocation amount. /// Calculates VAT amount using VAT posting group configuration and allocation base amount. /// </summary> /// <param name="GenJnlLine">General journal line record providing VAT calculation context for this allocation.</param> procedure UpdateVAT(var GenJnlLine: Record "Gen. Journal Line") var GenJnlLine2: Record "Gen. Journal Line"; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateVAT(GenJnlLine, IsHandled, Rec); if not IsHandled then begin GenJnlLine2.CopyFromGenJnlAllocation(Rec); GenJnlLine2."Posting Date" := GenJnlLine."Posting Date"; GenJnlLine2.Validate("VAT Prod. Posting Group"); Amount := GenJnlLine2."Amount (LCY)"; "VAT Calculation Type" := GenJnlLine2."VAT Calculation Type"; "VAT Amount" := GenJnlLine2."VAT Amount"; "VAT %" := GenJnlLine2."VAT %"; end; OnAfterUpdateVAT(GenJnlLine, GenJnlLine2, Rec); end; /// <summary> /// Retrieves the currency code applicable to this allocation line based on the associated journal line. /// Returns the journal line's currency code or LCY if no specific currency is defined. /// </summary> /// <returns>Currency code for this allocation line's amounts and VAT calculations.</returns> procedure GetCurrencyCode(): Code[10] var GenJnlLine3: Record "Gen. Journal Line"; begin GenJnlLine3.SetRange("Journal Template Name", "Journal Template Name"); GenJnlLine3.SetRange("Journal Batch Name", "Journal Batch Name"); GenJnlLine3.SetRange("Line No.", "Journal Line No."); if GenJnlLine3.FindFirst() then exit(GenJnlLine3."Currency Code"); exit(''); end; local procedure GetAdditionalReportingCurrencyCode(): Code[10] var GLSetup: Record "General Ledger Setup"; begin if GLSetup.Get() then exit(GLSetup."Additional Reporting Currency"); exit(''); end; /// <summary> /// Creates dimension set for this allocation line from the specified default dimension sources. /// Builds dimension combinations for financial analysis and reporting requirements. /// </summary> /// <param name="DefaultDimSource">List of default dimension sources to use for dimension set creation.</param> procedure CreateDim(DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]) var IsHandled: Boolean; OldDimSetID: Integer; begin IsHandled := false; OnBeforeCreateDim(Rec, IsHandled); if IsHandled then exit; "Shortcut Dimension 1 Code" := ''; "Shortcut Dimension 2 Code" := ''; OldDimSetID := Rec."Dimension Set ID"; "Dimension Set ID" := DimMgt.GetRecDefaultDimID(Rec, CurrFieldNo, DefaultDimSource, '', "Shortcut Dimension 1 Code", "Shortcut Dimension 2 Code", 0, 0); OnAfterCreateDimProcedure(Rec, CurrFieldNo, DefaultDimSource, xRec, OldDimSetID); end; /// <summary> /// Validates shortcut dimension code for the specified dimension and updates the allocation line's dimension set. /// Ensures dimension values are valid and updates the dimension set ID accordingly. /// </summary> /// <param name="FieldNumber">Field number indicating which shortcut dimension is being validated.</param> /// <param name="ShortcutDimCode">Shortcut dimension code value to validate and assign.</param> procedure ValidateShortcutDimCode(FieldNumber: Integer; var ShortcutDimCode: Code[20]) begin OnBeforeValidateShortcutDimCode(Rec, xRec, FieldNumber, ShortcutDimCode); DimMgt.ValidateShortcutDimValues(FieldNumber, ShortcutDimCode, "Dimension Set ID"); OnAfterValidateShortcutDimCode(Rec, xRec, FieldNumber, ShortcutDimCode); end; /// <summary> /// Opens lookup for shortcut dimension code selection and updates the allocation line's dimension set. /// Provides user interface for selecting valid dimension values for the specified dimension. /// </summary> /// <param name="FieldNumber">Field number indicating which shortcut dimension lookup should be opened.</param> /// <param name="ShortcutDimCode">Current shortcut dimension code value, updated with user selection.</param> procedure LookupShortcutDimCode(FieldNumber: Integer; var ShortcutDimCode: Code[20]) begin DimMgt.LookupDimValueCode(FieldNumber, ShortcutDimCode); DimMgt.ValidateShortcutDimValues(FieldNumber, ShortcutDimCode, "Dimension Set ID"); end; /// <summary> /// Retrieves and displays shortcut dimension codes for this allocation line in the provided array. /// Populates shortcut dimension code array with current dimension values for display purposes. /// </summary> /// <param name="ShortcutDimCode">Array to populate with current shortcut dimension codes from this allocation.</param> procedure ShowShortcutDimCode(var ShortcutDimCode: array[8] of Code[20]) begin DimMgt.GetShortcutDimensions(Rec."Dimension Set ID", ShortcutDimCode); end; /// <summary> /// Opens the dimensions page to display and allow editing of all dimensions for this allocation line. /// Provides comprehensive dimension management interface for detailed financial analysis setup. /// </summary> procedure ShowDimensions() begin "Dimension Set ID" := DimMgt.EditDimensionSet(Rec, "Dimension Set ID", StrSubstNo('%1 %2 %3', "Journal Template Name", "Journal Batch Name", "Journal Line No."), "Shortcut Dimension 1 Code", "Shortcut Dimension 2 Code"); OnAfterShowDimensions(Rec, xRec); end; /// <summary> /// Creates dimension set for this allocation line from default dimension setup for the G/L account. /// Automatically applies standard dimension configuration based on account and posting group defaults. /// </summary> procedure CreateDimFromDefaultDim() var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; begin InitDefaultDimensionSources(DefaultDimSource); CreateDim(DefaultDimSource); end; local procedure InitDefaultDimensionSources(var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]) begin DimMgt.AddDimSource(DefaultDimSource, Database::"G/L Account", Rec."Account No."); OnAfterInitDefaultDimensionSources(Rec, DefaultDimSource); end; internal procedure ChooseAndImportFromAllocationAccount() var AllocationAccount: Record "Allocation Account"; begin if ChooseAllocationAccount(AllocationAccount) then ImportFromAllocationAccount(AllocationAccount); end; local procedure ChooseAllocationAccount(var AllocationAccount: Record "Allocation Account") AccountChosen: Boolean var AllocationAccountList: Page "Allocation Account List"; begin AllocationAccount.SetRange("Account Type", AllocationAccount."Account Type"::Fixed); AllocationAccountList.SetTableView(AllocationAccount); AllocationAccountList.LookupMode(true); if AllocationAccountList.RunModal() = Action::LookupOK then begin AccountChosen := true; AllocationAccountList.GetRecord(AllocationAccount); end; end; local procedure ImportFromAllocationAccount(AllocationAccount: Record "Allocation Account") var AllocAccountDistribution: Record "Alloc. Account Distribution"; ConfirmManagement: Codeunit "Confirm Management"; NextLineNo: Integer; begin if not Rec.IsEmpty() then if not ConfirmManagement.GetResponse(ImportDeletesExistingLinesQst) then exit; Rec.DeleteAll(); AllocationAccount.TestField("Account Type", AllocationAccount."Account Type"::Fixed); AllocAccountDistribution.SetRange("Allocation Account No.", AllocationAccount."No."); NextLineNo := 10000; CheckAccountType(AllocAccountDistribution); if AllocAccountDistribution.FindSet() then repeat Rec.Init(); Rec."Line No." := NextLineNo; Rec.Insert(); NextLineNo += 10000; CopyFieldsFromAllocationAccountDistribution(AllocAccountDistribution); until AllocAccountDistribution.Next() = 0; end; local procedure CheckAccountType(var AllocAccountDistribution: Record "Alloc. Account Distribution") begin AllocAccountDistribution.SetFilter("Destination Account Type", '<>%1', AllocAccountDistribution."Destination Account Type"::"G/L Account"); if not AllocAccountDistribution.IsEmpty() then Error(AllocAccountImportWrongAccTypeErr); AllocAccountDistribution.SetRange("Destination Account Type"); end; local procedure CopyFieldsFromAllocationAccountDistribution(AllocAccountDistribution: Record "Alloc. Account Distribution") begin Rec.Validate("Account No.", AllocAccountDistribution."Destination Account Number"); Rec.Validate("Allocation %", AllocAccountDistribution.Percent); Rec.Validate("Shortcut Dimension 1 Code", AllocAccountDistribution."Global Dimension 1 Code"); Rec.Validate("Shortcut Dimension 2 Code", AllocAccountDistribution."Global Dimension 2 Code"); Rec.Validate("Dimension Set ID", AllocAccountDistribution."Dimension Set ID"); Rec.Modify(true); end; local procedure CheckGLAccount(var GLAccount: Record "G/L Account") var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckGLAccount(GLAccount, IsHandled, Rec); if IsHandled then exit; GLAccount.TestField("Direct Posting", true); OnAfterCheckGLAccount(GLAccount, Rec); end; /// <summary> /// Integration event raised after initializing default dimension sources for allocation line dimension creation. /// Enables custom modification of dimension sources before dimension set creation for allocation lines. /// </summary> /// <param name="GenJnlAllocation">General journal allocation record for which dimension sources are being initialized.</param> /// <param name="DefaultDimSource">List of default dimension sources that can be modified for custom dimension logic.</param> [IntegrationEvent(false, false)] local procedure OnAfterInitDefaultDimensionSources(var GenJnlAllocation: Record "Gen. Jnl. Allocation"; var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]) begin end; /// <summary> /// Integration event raised before creating dimension set for allocation line. /// Enables custom logic to completely override standard dimension creation processing for allocations. /// </summary> /// <param name="GenJnlAllocation">General journal allocation record for which dimensions are being created.</param> /// <param name="IsHandled">Set to true to skip standard dimension creation logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCreateDim(var GenJnlAllocation: Record "Gen. Jnl. Allocation"; var IsHandled: Boolean); begin end; /// <summary> /// Integration event raised after completing dimension creation procedure for allocation line. /// Enables custom processing and validation after standard dimension set creation is completed. /// </summary> /// <param name="GenJnlAllocation">General journal allocation record for which dimensions were created.</param> /// <param name="CurrFieldNo">Field number that triggered the dimension creation process.</param> /// <param name="DefaultDimSource">List of default dimension sources used in dimension creation.</param> /// <param name="xGenJnlAllocation">Previous version of allocation record before dimension changes.</param> /// <param name="OldDimSetID">Previous dimension set ID before changes were applied.</param> [IntegrationEvent(false, false)] local procedure OnAfterCreateDimProcedure(var GenJnlAllocation: Record "Gen. Jnl. Allocation"; CurrFieldNo: Integer; DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; xGenJnlAllocation: Record "Gen. Jnl. Allocation"; OldDimSetID: Integer); begin end; /// <summary> /// Integration event raised after displaying dimensions page for allocation line. /// Enables custom processing after user interaction with allocation line dimensions. /// </summary> /// <param name="GenJnlAllocation">General journal allocation record for which dimensions were displayed.</param> /// <param name="xGenJnlAllocation">Previous version of allocation record before dimension display interaction.</param> [IntegrationEvent(false, false)] local procedure OnAfterShowDimensions(var GenJnlAllocation: Record "Gen. Jnl. Allocation"; xGenJnlAllocation: Record "Gen. Jnl. Allocation") begin end; /// <summary> /// Integration event raised after validating shortcut dimension code for allocation line. /// Enables custom processing after shortcut dimension validation and dimension set updates. /// </summary> /// <param name="GenJnlAllocation">General journal allocation record for which shortcut dimension was validated.</param> /// <param name="xGenJnlAllocation">Previous version of allocation record before shortcut dimension validation.</param> /// <param name="FieldNumber">Field number indicating which shortcut dimension was validated.</param> /// <param name="ShortcutDimCode">Shortcut dimension code value that was validated and applied.</param> [IntegrationEvent(false, false)] local procedure OnAfterValidateShortcutDimCode(var GenJnlAllocation: Record "Gen. Jnl. Allocation"; var xGenJnlAllocation: Record "Gen. Jnl. Allocation"; FieldNumber: Integer; var ShortcutDimCode: Code[20]) begin end; /// <summary> /// Integration event raised before validating shortcut dimension code for allocation line. /// Enables custom logic to override standard shortcut dimension validation processing. /// </summary> /// <param name="GenJnlAllocation">General journal allocation record for which shortcut dimension is being validated.</param> /// <param name="xGenJnlAllocation">Previous version of allocation record before shortcut dimension validation.</param> /// <param name="FieldNumber">Field number indicating which shortcut dimension is being validated.</param> /// <param name="ShortcutDimCode">Shortcut dimension code value being validated (can be modified).</param> [IntegrationEvent(false, false)] local procedure OnBeforeValidateShortcutDimCode(var GenJnlAllocation: Record "Gen. Jnl. Allocation"; var xGenJnlAllocation: Record "Gen. Jnl. Allocation"; FieldNumber: Integer; var ShortcutDimCode: Code[20]) begin end; /// <summary> /// Integration event that occurs after modifying a general journal allocation line during update process. /// Allows customization of allocation line processing after standard modification logic. /// </summary> /// <param name="GenJnlAlloc">The general journal allocation record that was modified.</param> [IntegrationEvent(false, false)] local procedure OnUpdateAllocationsOnAfterGenJnlAllocModify(var GenJnlAlloc: Record "Gen. Jnl. Allocation") begin end; /// <summary> /// Integration event that occurs before modifying a general journal allocation line during update process. /// Allows customization of allocation line values before standard modification logic. /// </summary> /// <param name="GenJournalLine">The source general journal line being processed.</param> /// <param name="GenJnlAlloc">The general journal allocation record being modified.</param> [IntegrationEvent(false, false)] local procedure OnUpdateAllocationsOnBeforeGenJnlAllocModify(GenJournalLine: Record "Gen. Journal Line"; var GenJnlAlloc: Record "Gen. Jnl. Allocation") begin end; /// <summary> /// Integration event raised after modifying allocation line during additional currency allocation updates. /// Enables custom processing after allocation line changes during ACY amount distribution. /// </summary> /// <param name="GenJnlAlloc">General journal allocation record that was modified during ACY update process.</param> [IntegrationEvent(false, false)] local procedure OnUpdateAllocationsAddCurrOnAfterGenJnlAllocModify(var GenJnlAlloc: Record "Gen. Jnl. Allocation") begin end; /// <summary> /// Integration event raised before validating G/L account setup for allocation line. /// Enables custom logic to override standard G/L account validation processing for allocations. /// </summary> /// <param name="GLAccount">G/L Account record being validated for allocation line usage.</param> /// <param name="IsHandled">Set to true to skip standard G/L account validation logic.</param> /// <param name="GenJnlAllocation">General journal allocation record providing context for G/L account validation.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckGLAccount(GLAccount: Record "G/L Account"; var IsHandled: Boolean; var GenJnlAllocation: Record "Gen. Jnl. Allocation"); begin end; /// <summary> /// Integration event raised after validating G/L account setup for allocation line. /// Enables custom processing and validation after standard G/L account checks are completed. /// </summary> /// <param name="GLAccount">G/L Account record that was validated for allocation line usage.</param> /// <param name="GenJnlAllocation">General journal allocation record providing context for G/L account validation.</param> [IntegrationEvent(false, false)] local procedure OnAfterCheckGLAccount(var GLAccount: Record "G/L Account"; GenJnlAllocation: Record "Gen. Jnl. Allocation") begin end; /// <summary> /// Integration event raised before updating VAT amounts for allocation line. /// Enables custom logic to completely override standard VAT update processing for allocations. /// </summary> /// <param name="GenJournalLine">General journal line record providing VAT update context.</param> /// <param name="IsHandled">Set to true to skip standard VAT update logic.</param> /// <param name="GenJnlAllocation">General journal allocation record for which VAT is being updated.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateVAT(var GenJournalLine: Record "Gen. Journal Line"; var IsHandled: Boolean; var GenJnlAllocation: Record "Gen. Jnl. Allocation") begin end; /// <summary> /// Integration event raised after updating VAT amounts for allocation line. /// Enables custom processing after standard VAT calculation and update is completed. /// </summary> /// <param name="GenJournalLine">General journal line record that provided VAT update context.</param> /// <param name="GenJournalLine2">Additional journal line record used during VAT update process.</param> /// <param name="GenJnlAllocation">General journal allocation record for which VAT was updated.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateVAT(var GenJournalLine: Record "Gen. Journal Line"; GenJournalLine2: Record "Gen. Journal Line"; var GenJnlAllocation: Record "Gen. Jnl. Allocation") begin end; /// <summary> /// Integration event raised before validating account number for allocation line. /// Enables custom logic to completely override standard account number validation processing. /// </summary> /// <param name="GenJnlAllocation">General journal allocation record for which account number is being validated.</param> /// <param name="xGenJnlAllocation">Previous version of allocation record before account number validation.</param> /// <param name="IsHandled">Set to true to skip standard account number validation logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeValidateAccountNo(var GenJnlAllocation: Record "Gen. Jnl. Allocation"; xGenJnlAllocation: Record "Gen. Jnl. Allocation"; var IsHandled: Boolean) begin end;}