Table 221 Gen. Jnl. Allocation, source in 29
Source29
src/Layers/W1/BaseApp/Finance/GeneralLedger/Journal/GenJnlAllocation.Table.al1027 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;
}