Codeunit 408 DimensionManagement, source in 29
Source29
src/Layers/W1/BaseApp/Finance/Dimension/DimensionManagement.Codeunit.al4171 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.
// ------------------------------------------------------------------------------------------------
/// <summary>
/// Codeunit DimensionManagement (ID 408).
/// This codeunit provides comprehensive dimension management functionality including validation, default dimension handling,
/// dimension set management, and integration with various document types and journal entries.
/// It serves as the central engine for all dimension-related operations in the system.
/// </summary>
namespace Microsoft.Finance.Dimension;
using Microsoft.Assembly.Document;
using Microsoft.Bank.BankAccount;
using Microsoft.Bank.Reconciliation;
using Microsoft.CostAccounting.Setup;
using Microsoft.Finance.GeneralLedger.Account;
using Microsoft.Finance.GeneralLedger.Journal;
using Microsoft.Finance.GeneralLedger.Setup;
using Microsoft.FixedAssets.FixedAsset;
using Microsoft.Foundation.AuditCodes;
using Microsoft.HumanResources.Employee;
using Microsoft.Intercompany.Dimension;
using Microsoft.Intercompany.Partner;
using Microsoft.Inventory.Item;
using Microsoft.Inventory.Location;
using Microsoft.Inventory.Requisition;
using Microsoft.Inventory.Transfer;
using Microsoft.Projects.Project.Job;
using Microsoft.Projects.Project.Journal;
using Microsoft.Projects.Resources.Resource;
using Microsoft.Purchases.Document;
using Microsoft.Purchases.Payables;
using Microsoft.Purchases.Vendor;
using Microsoft.Sales.Customer;
using Microsoft.Sales.Document;
using Microsoft.Sales.FinanceCharge;
using Microsoft.Sales.Receivables;
using Microsoft.Sales.Reminder;
using Microsoft.Utilities;
using System.Environment.Configuration;
using System.Globalization;
using System.Reflection;
using System.Utilities;
/// <summary>
/// Codeunit DimensionManagement (ID 408).
/// Central management system for all dimension-related operations including validation,
/// default dimension processing, dimension set creation and management, and integration
/// with documents and journal entries across all application areas.
/// </summary>
codeunit 408 DimensionManagement
{
Permissions = TableData "Gen. Journal Template" = rimd,
TableData "Gen. Journal Batch" = rimd,
tabledata "Default Dimension" = R,
tabledata "Dimension Set Entry" = R;
trigger OnRun()
begin
end;
var
#pragma warning disable AA0074
#pragma warning disable AA0470
Text000: Label 'Dimensions %1 and %2 can''t be used concurrently.';
Text001: Label 'Dimension combinations %1 - %2 and %3 - %4 can''t be used concurrently.';
ShortcutDimensionNotDefinedErr: Label 'Shortcut Dimension %2 is not defined in the %1.', Comment = '%1 - Table Caption, %2 - Shortcut Dimension No.';
Text003: Label '%1 is not an available %2 for that dimension.';
#pragma warning restore AA0470
#pragma warning restore AA0074
DefaultDimensionsValueCodeEmptyTxt: Label 'The %1 dimension is the default dimension, and it must have a value. You can set the value on the %2 page.', Comment = '%1 = the value of Dimension Code; %2 = page caption of Default Dimensions';
#pragma warning disable AA0074
#pragma warning disable AA0470
Text005: Label 'Select a %1 for the %2 %3 for %4 %5.';
#pragma warning restore AA0470
#pragma warning restore AA0074
SameCodeWrongDimOrNoCode01Err: Label 'The %1 must be %2 for %3 %4. Currently it''s %5.', Comment = '%1 = "Dimension value code" caption, %2 = expected "Dimension value code" value, %3 = "Dimension code" caption, %4 = "Dimension Code" value, %5 = current "Dimension value code" value';
SameCodeWrongDimOrNoCode02Err: Label 'The %1 must be %2 for %3 %4 for %5 %6. Currently it''s %7.', Comment = '%1 = "Dimension value code" caption, %2 = expected "Dimension value code" value, %3 = "Dimension code" caption, %4 = "Dimension Code" value, %5 = Table caption (Vendor), %6 = Table value (XYZ), %7 = current "Dimension value code" value';
BlankValueLbl: Label 'blank', Comment = 'This can be used with SameCodeWrongDimOrNoCode02Err. Example: The Dimension Value Code must be blank for Dimension code SALESCAMPAIGN for Vendor 10000. Currently it''s SUMMER.';
SameCodeMissingDim01Err: Label 'The %1 %2 with %3 %4 is required.', Comment = '%1 = "Dimension code" caption, %2= "Dimension Code" value, %3 = "Dimension value code" caption, %4 = "Dimension value code" value';
SameCodeMissingDim02Err: Label 'The %1 %2 with %3 %4 is required for %5 %6.', Comment = '%1 = "Dimension code" caption, %2= "Dimension Code" value, %3 = "Dimension value code" caption, %4 = "Dimension value code" value, %5 = Table caption (Vendor), %6 = Table value (XYZ)';
#pragma warning disable AA0074
#pragma warning disable AA0470
Text008: Label '%1 %2 must be blank.';
Text009: Label '%1 %2 must be blank for %3 %4.';
Text012: Label 'A %1 used in %2 has not been used in %3.';
Text013: Label '%1 for %2 %3 is not the same in %4 and %5.';
Text014: Label '%1 %2 is blocked.';
Text015: Label '%1 %2 can''t be found.';
#pragma warning restore AA0470
#pragma warning restore AA0074
DimValueBlockedErr: Label '%1 %2 - %3 is blocked.', Comment = '%1 = Dimension Value table caption, %2 = Dim Code, %3 = Dim Value';
DimValueMustNotBeErr: Label 'Dimension Value Type for %1 %2 - %3 must not be %4.', Comment = '%1 = Dimension Value table caption, %2 = Dim Code, %3 = Dim Value, %4 = Dimension Value Type value';
DimValueMissingErr: Label '%1 %2 - %3 is missing.', Comment = '%1 = Dimension Value table caption, %2 = Dim Code, %3 = Dim Value';
#pragma warning disable AA0074
Text019: Label 'You have changed a dimension.\\Do you want to update the lines?';
#pragma warning restore AA0074
DimValueNotAllowedForAccountErr: Label 'Dimension value %1, %2 is not allowed for %3, %4.', Comment = '%1 = Dim Code, %2 = Dim Value, %3 - table caption, %4 - account number.';
DimValueNotAllowedForAccountTypeErr: Label 'Dimension value %1 %2 is not allowed for account type %3.', Comment = '%1 = Dim Code, %2 = Dim Value, %3 - table caption.';
ToManyParametersErr: Label 'This filter selection exceeds the number of parameters that can be passed to SQL. Please reduce the number by adding additional filters.';
NoAllowedValuesSelectedErr: Label 'There are no allowed dimension values selected.';
DefaultDimPrioritiesMissingLbl: Label 'Default Dimension Priorities are not defined for Source Code: %1.', Comment = '%1 = Source Code';
AllowedDimensionValueConfirmTxt: Label 'Do you want dimension value %1 to be included in %2 in %3 default dimensions? Updating default dimensions may take some time.', Comment = '%1 = Dimension Value, %2 = Allowed Values Filter, %3 = No. of Default Dimension records that will be updated.';
HideNotificationTxt: Label 'Don''t show again';
OpenDefaultDimPrioritiesLbl: Label 'Do you want to initialize Dimension Priorities?';
LastErrorMessage: Record "Error Message";
TempJobTaskDimBuffer: Record "Job Task Dimension" temporary;
TempDimSetEntryBuffer: Record "Dimension Set Entry" temporary;
ErrorMessageMgt: Codeunit "Error Message Management";
InstructionMgt: Codeunit "Instruction Mgt.";
TempDimCombInitialized: Boolean;
TempDimCombEmpty: Boolean;
HasGotGLSetup: Boolean;
GLSetupShortcutDimCode: array[8] of Code[20];
DimSetFilterCtr: Integer;
IsCollectErrorsMode: Boolean;
SkipChangeDimensionsQst: Boolean;
SkipUpdateDimensions: Boolean;
SourceCode: Code[10];
/// <summary>
/// Enables error collection mode to accumulate dimension-related errors instead of immediately throwing them.
/// Used in batch processing scenarios where multiple validation errors need to be collected and reported together.
/// </summary>
procedure SetCollectErrorsMode()
begin
IsCollectErrorsMode := true;
end;
/// <summary>
/// Sets the source code for dimension operations based on the table ID.
/// Determines appropriate source code from Source Code Setup for different document types and journal entries.
/// </summary>
/// <param name="TableID">Table ID to determine the appropriate source code for dimension operations</param>
procedure SetSourceCode(TableID: Integer)
var
SourceCodeSetup: Record "Source Code Setup";
begin
SourceCodeSetup.Get();
case TableID of
Database::"Sales Header",
Database::"Sales Line":
SourceCode := SourceCodeSetup.Sales;
Database::"Purchase Header",
Database::"Purchase Line",
Database::"Requisition Line":
SourceCode := SourceCodeSetup.Purchases;
Database::"Bank Acc. Reconciliation",
Database::"Bank Acc. Reconciliation Line":
SourceCode := SourceCodeSetup."Payment Reconciliation Journal";
Database::"Reminder Header":
SourceCode := SourceCodeSetup.Reminder;
Database::"Finance Charge Memo Header":
SourceCode := SourceCodeSetup."Finance Charge Memo";
Database::"Assembly Header",
Database::"Assembly Line":
SourceCode := SourceCodeSetup.Assembly;
Database::"Transfer Line":
SourceCode := SourceCodeSetup.Transfer;
end;
OnAfterSetSourceCode(SourceCodeSetup, TableID, SourceCode);
end;
/// <summary>
/// Sets the source code for dimension operations based on the table ID and record variant.
/// Extends the standard SetSourceCode procedure with additional record context for specialized handling.
/// </summary>
/// <param name="TableID">Table ID to determine the appropriate source code for dimension operations</param>
/// <param name="RecordVar">Record variant providing additional context for source code determination</param>
procedure SetSourceCode(TableID: Integer; RecordVar: Variant)
begin
SetSourceCode(TableID);
OnAfterSetSourceCodeWithVar(TableID, RecordVar, SourceCode);
end;
/// <summary>
/// Returns the current source code set for dimension operations.
/// Used to retrieve the source code that was previously set via SetSourceCode procedures.
/// </summary>
/// <returns>Source code currently active for dimension operations</returns>
procedure GetSourceCode(): Code[10]
begin
exit(SourceCode);
end;
/// <summary>
/// Gets or creates a dimension set ID from the provided dimension set entries.
/// Creates a new dimension set if the combination doesn't exist, or returns existing set ID.
/// </summary>
/// <param name="DimSetEntry2">Dimension set entries to find or create dimension set ID for</param>
/// <returns>Dimension set ID corresponding to the provided dimension entries</returns>
procedure GetDimensionSetID(var DimSetEntry2: Record "Dimension Set Entry"): Integer
var
DimSetEntry: Record "Dimension Set Entry";
begin
OnBeforeGetDimensionSetIDProcedure(DimSetEntry2);
exit(DimSetEntry.GetDimensionSetID(DimSetEntry2));
end;
/// <summary>
/// Retrieves all dimension set entries for a specific dimension set ID.
/// Populates the temporary dimension set entry record with all dimensions from the specified set.
/// </summary>
/// <param name="TempDimSetEntry">Temporary dimension set entry record to populate with dimension data</param>
/// <param name="DimSetID">Dimension set ID to retrieve entries for</param>
procedure GetDimensionSet(var TempDimSetEntry: Record "Dimension Set Entry" temporary; DimSetID: Integer)
var
DimSetEntry: Record "Dimension Set Entry";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeGetDimensionSet(TempDimSetEntry, DimSetID, IsHandled);
if IsHandled then
exit;
TempDimSetEntry.DeleteAll();
DimSetEntry.SetRange("Dimension Set ID", DimSetID);
if DimSetEntry.FindSet() then
repeat
TempDimSetEntry := DimSetEntry;
TempDimSetEntry.Insert();
until DimSetEntry.Next() = 0;
end;
/// <summary>
/// Displays the dimension set entries in a read-only modal page.
/// Shows all dimension values associated with the specified dimension set ID.
/// </summary>
/// <param name="DimSetID">Dimension set ID to display entries for</param>
/// <param name="NewCaption">Caption to display on the dimension set entries page</param>
procedure ShowDimensionSet(DimSetID: Integer; NewCaption: Text[250])
var
DimSetEntry: Record "Dimension Set Entry";
DimSetEntries: Page "Dimension Set Entries";
begin
DimSetEntry.Reset();
DimSetEntry.FilterGroup(2);
DimSetEntry.SetRange("Dimension Set ID", DimSetID);
DimSetEntry.FilterGroup(0);
DimSetEntries.SetTableView(DimSetEntry);
DimSetEntries.SetFormCaption(NewCaption);
DimSetEntries.RunModal();
end;
/// <summary>
/// Opens the dimension set editor for modifying dimensions and returns the new dimension set ID.
/// Allows user to edit dimension values and creates a new dimension set if changes are made.
/// </summary>
/// <param name="DimSetID">Original dimension set ID to edit</param>
/// <param name="NewCaption">Caption to display on the dimension editor page</param>
/// <returns>New dimension set ID after editing, or original ID if no changes made</returns>
procedure EditDimensionSet(DimSetID: Integer; NewCaption: Text[250]): Integer
var
DimSetEntry: Record "Dimension Set Entry";
EditDimSetEntries: Page "Edit Dimension Set Entries";
NewDimSetID: Integer;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeEditDimensionSet(DimSetID, NewCaption, NewDimSetID, IsHandled);
if IsHandled then
exit(NewDimSetID);
NewDimSetID := DimSetID;
DimSetEntry.Reset();
DimSetEntry.FilterGroup(2);
DimSetEntry.SetRange("Dimension Set ID", DimSetID);
DimSetEntry.FilterGroup(0);
EditDimSetEntries.SetTableView(DimSetEntry);
EditDimSetEntries.SetFormCaption(NewCaption);
OnEditDimensionSetOnBeforeEditDimEntries(EditDimSetEntries);
EditDimSetEntries.RunModal();
NewDimSetID := EditDimSetEntries.GetDimensionID();
OnAfterEditDimensionSet(NewDimSetID);
exit(NewDimSetID);
end;
/// <summary>
/// Opens the dimension set editor and updates global dimension values after editing.
/// Convenience procedure that combines dimension editing with global dimension value updates.
/// </summary>
/// <param name="DimSetID">Original dimension set ID to edit</param>
/// <param name="NewCaption">Caption to display on the dimension editor page</param>
/// <param name="GlobalDimVal1">Variable to receive updated global dimension 1 value</param>
/// <param name="GlobalDimVal2">Variable to receive updated global dimension 2 value</param>
/// <returns>New dimension set ID after editing, or original ID if no changes made</returns>
procedure EditDimensionSet(DimSetID: Integer; NewCaption: Text[250]; var GlobalDimVal1: Code[20]; var GlobalDimVal2: Code[20]): Integer
var
RecVariant: Variant;
begin
exit(EditDimensionSet(RecVariant, DimSetID, NewCaption, GlobalDimVal1, GlobalDimVal2));
end;
/// <summary>
/// Opens the dimension set editor with record context and updates global dimension values.
/// Extended version providing record variant context for specialized dimension handling.
/// </summary>
/// <param name="RecVariant">Record variant providing context for dimension editing</param>
/// <param name="DimSetID">Original dimension set ID to edit</param>
/// <param name="NewCaption">Caption to display on the dimension editor page</param>
/// <param name="GlobalDimVal1">Variable to receive updated global dimension 1 value</param>
/// <param name="GlobalDimVal2">Variable to receive updated global dimension 2 value</param>
/// <returns>New dimension set ID after editing, or original ID if no changes made</returns>
procedure EditDimensionSet(RecVariant: Variant; DimSetID: Integer; NewCaption: Text[250]; var GlobalDimVal1: Code[20]; var GlobalDimVal2: Code[20]): Integer
var
DimSetEntry: Record "Dimension Set Entry";
EditDimSetEntries: Page "Edit Dimension Set Entries";
NewDimSetID: Integer;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeEditDimensionSet2(DimSetID, NewCaption, GlobalDimVal1, GlobalDimVal2, NewDimSetID, IsHandled, RecVariant);
if IsHandled then
exit(NewDimSetID);
NewDimSetID := DimSetID;
DimSetEntry.Reset();
DimSetEntry.FilterGroup(2);
DimSetEntry.SetRange("Dimension Set ID", DimSetID);
DimSetEntry.FilterGroup(0);
EditDimSetEntries.SetTableView(DimSetEntry);
EditDimSetEntries.SetFormCaption(NewCaption);
OnEditDimensionSetOnBeforeEditDimEntries(EditDimSetEntries);
EditDimSetEntries.RunModal();
NewDimSetID := EditDimSetEntries.GetDimensionID();
UpdateGlobalDimFromDimSetID(NewDimSetID, GlobalDimVal1, GlobalDimVal2);
OnAfterEditDimensionSet2(NewDimSetID, GlobalDimVal1, GlobalDimVal2);
exit(NewDimSetID);
end;
/// <summary>
/// Opens the reclassification dimension editor for modifying both source and destination dimensions.
/// Used in reclassification scenarios where both original and new dimension sets need to be edited.
/// </summary>
/// <param name="DimSetID">Source dimension set ID to edit</param>
/// <param name="NewDimSetID">Destination dimension set ID to edit</param>
/// <param name="NewCaption">Caption to display on the reclassification dimension editor page</param>
/// <param name="GlobalDimVal1">Variable to receive updated source global dimension 1 value</param>
/// <param name="GlobalDimVal2">Variable to receive updated source global dimension 2 value</param>
/// <param name="NewGlobalDimVal1">Variable to receive updated destination global dimension 1 value</param>
/// <param name="NewGlobalDimVal2">Variable to receive updated destination global dimension 2 value</param>
procedure EditReclasDimensionSet(var DimSetID: Integer; var NewDimSetID: Integer; NewCaption: Text[250]; var GlobalDimVal1: Code[20]; var GlobalDimVal2: Code[20]; var NewGlobalDimVal1: Code[20]; var NewGlobalDimVal2: Code[20])
var
EditReclasDimensions: Page "Edit Reclas. Dimensions";
begin
EditReclasDimensions.SetDimensionIDs(DimSetID, NewDimSetID);
EditReclasDimensions.SetFormCaption(NewCaption);
EditReclasDimensions.RunModal();
EditReclasDimensions.GetDimensionIDs(DimSetID, NewDimSetID);
UpdateGlobalDimFromDimSetID(DimSetID, GlobalDimVal1, GlobalDimVal2);
UpdateGlobalDimFromDimSetID(NewDimSetID, NewGlobalDimVal1, NewGlobalDimVal2);
end;
/// <summary>
/// Updates global dimension values from a dimension set ID.
/// Retrieves the first two global dimension values from the specified dimension set.
/// </summary>
/// <param name="DimSetID">Dimension set ID to extract global dimension values from</param>
/// <param name="GlobalDimVal1">Variable to receive global dimension 1 value</param>
/// <param name="GlobalDimVal2">Variable to receive global dimension 2 value</param>
procedure UpdateGlobalDimFromDimSetID(DimSetID: Integer; var GlobalDimVal1: Code[20]; var GlobalDimVal2: Code[20])
var
ShortcutDimCode: array[8] of Code[20];
begin
GetGlobalDimensions(DimSetID, ShortcutDimCode);
GlobalDimVal1 := ShortcutDimCode[1];
GlobalDimVal2 := ShortcutDimCode[2];
end;
/// <summary>
/// Combines multiple dimension sets into a single dimension set ID.
/// Merges dimensions from up to 10 different dimension sets, with later sets overriding earlier ones for same dimensions.
/// </summary>
/// <param name="DimensionSetIDArr">Array of dimension set IDs to combine</param>
/// <param name="GlobalDimVal1">Variable to receive combined global dimension 1 value</param>
/// <param name="GlobalDimVal2">Variable to receive combined global dimension 2 value</param>
/// <returns>New dimension set ID containing combined dimensions</returns>
procedure GetCombinedDimensionSetID(DimensionSetIDArr: array[10] of Integer; var GlobalDimVal1: Code[20]; var GlobalDimVal2: Code[20]): Integer
var
DimSetEntry: Record "Dimension Set Entry";
TempDimSetEntry: Record "Dimension Set Entry" temporary;
i: Integer;
begin
GetGLSetup(GLSetupShortcutDimCode);
GlobalDimVal1 := '';
GlobalDimVal2 := '';
DimSetEntry.Reset();
for i := 1 to 10 do
if DimensionSetIDArr[i] <> 0 then begin
DimSetEntry.SetRange("Dimension Set ID", DimensionSetIDArr[i]);
if DimSetEntry.FindSet() then
repeat
if TempDimSetEntry.Get(0, DimSetEntry."Dimension Code") then
TempDimSetEntry.Delete();
TempDimSetEntry := DimSetEntry;
TempDimSetEntry."Dimension Set ID" := 0;
TempDimSetEntry.Insert();
if GLSetupShortcutDimCode[1] = TempDimSetEntry."Dimension Code" then
GlobalDimVal1 := TempDimSetEntry."Dimension Value Code";
if GLSetupShortcutDimCode[2] = TempDimSetEntry."Dimension Code" then
GlobalDimVal2 := TempDimSetEntry."Dimension Value Code";
until DimSetEntry.Next() = 0;
end;
exit(GetDimensionSetID(TempDimSetEntry));
end;
/// <summary>
/// Calculates delta dimension set ID based on parent dimension set changes.
/// Updates a child dimension set when parent dimensions change, preserving child-specific dimensions.
/// </summary>
/// <param name="DimSetID">Original dimension set ID to update</param>
/// <param name="NewParentDimSetID">New parent dimension set ID</param>
/// <param name="OldParentDimSetID">Original parent dimension set ID</param>
/// <returns>Updated dimension set ID reflecting parent changes</returns>
procedure GetDeltaDimSetID(DimSetID: Integer; NewParentDimSetID: Integer; OldParentDimSetID: Integer): Integer
var
TempDimSetEntry: Record "Dimension Set Entry" temporary;
TempDimSetEntryNew: Record "Dimension Set Entry" temporary;
TempDimSetEntryDeleted: Record "Dimension Set Entry" temporary;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeGetDeltaDimSetID(DimSetID, NewParentDimSetID, OldParentDimSetID, IsHandled);
if IsHandled then
exit(DimSetID);
// Returns an updated DimSetID based on parent's old and new DimSetID
if NewParentDimSetID = OldParentDimSetID then
exit(DimSetID);
GetDimensionSet(TempDimSetEntry, DimSetID);
GetDimensionSet(TempDimSetEntryNew, NewParentDimSetID);
GetDimensionSet(TempDimSetEntryDeleted, OldParentDimSetID);
if TempDimSetEntryDeleted.FindSet() then
repeat
if TempDimSetEntryNew.Get(NewParentDimSetID, TempDimSetEntryDeleted."Dimension Code") then begin
if TempDimSetEntryNew."Dimension Value Code" = TempDimSetEntryDeleted."Dimension Value Code" then
TempDimSetEntryNew.Delete();
TempDimSetEntryDeleted.Delete();
end;
until TempDimSetEntryDeleted.Next() = 0;
if TempDimSetEntryDeleted.FindSet() then
repeat
if TempDimSetEntry.Get(DimSetID, TempDimSetEntryDeleted."Dimension Code") then
TempDimSetEntry.Delete();
until TempDimSetEntryDeleted.Next() = 0;
if TempDimSetEntryNew.FindSet() then
repeat
if TempDimSetEntry.Get(DimSetID, TempDimSetEntryNew."Dimension Code") then begin
if TempDimSetEntry."Dimension Value Code" <> TempDimSetEntryNew."Dimension Value Code" then begin
TempDimSetEntry."Dimension Value Code" := TempDimSetEntryNew."Dimension Value Code";
TempDimSetEntry."Dimension Value ID" := TempDimSetEntryNew."Dimension Value ID";
TempDimSetEntry.Modify();
end;
end else begin
TempDimSetEntry := TempDimSetEntryNew;
TempDimSetEntry."Dimension Set ID" := DimSetID;
TempDimSetEntry.Insert();
end;
until TempDimSetEntryNew.Next() = 0;
OnBeforeGetDimensionSetID(TempDimSetEntry);
exit(GetDimensionSetID(TempDimSetEntry));
end;
/// <summary>
/// Retrieves and caches General Ledger Setup shortcut dimension codes.
/// Loads all 8 shortcut dimension codes from General Ledger Setup for efficient repeated access.
/// </summary>
/// <param name="GLSetupShortcutDimCode">Array to populate with shortcut dimension codes from General Ledger Setup</param>
procedure GetGLSetup(var GLSetupShortcutDimCode: array[8] of Code[20])
var
GLSetup: Record "General Ledger Setup";
begin
if not HasGotGLSetup then begin
GLSetup.Get();
GLSetupShortcutDimCode[1] := GLSetup."Shortcut Dimension 1 Code";
GLSetupShortcutDimCode[2] := GLSetup."Shortcut Dimension 2 Code";
GLSetupShortcutDimCode[3] := GLSetup."Shortcut Dimension 3 Code";
GLSetupShortcutDimCode[4] := GLSetup."Shortcut Dimension 4 Code";
GLSetupShortcutDimCode[5] := GLSetup."Shortcut Dimension 5 Code";
GLSetupShortcutDimCode[6] := GLSetup."Shortcut Dimension 6 Code";
GLSetupShortcutDimCode[7] := GLSetup."Shortcut Dimension 7 Code";
GLSetupShortcutDimCode[8] := GLSetup."Shortcut Dimension 8 Code";
HasGotGLSetup := true;
end;
end;
local procedure GetLastDimErrorID(): Integer
begin
if ErrorMessageMgt.IsActive() then
exit(ErrorMessageMgt.GetCachedLastErrorID());
exit(LastErrorMessage.ID);
end;
local procedure FindLastErrorMessage(var Message: Text[250])
begin
if ErrorMessageMgt.IsActive() then
ErrorMessageMgt.GetLastError(Message)
else
Message := CopyStr(LastErrorMessage."Message", 1, MaxStrLen(Message));
end;
local procedure GetDimBufForDimSetID(DimSetID: Integer; var TempDimBuf: Record "Dimension Buffer" temporary)
var
DimSetEntry: Record "Dimension Set Entry";
begin
DimSetEntry.Reset();
DimSetEntry.SetRange("Dimension Set ID", DimSetID);
if DimSetEntry.FindSet() then
repeat
InsertTempDimBufEntry(TempDimBuf, Database::"Dimension Buffer", 0, DimSetEntry."Dimension Code", DimSetEntry."Dimension Value Code");
until DimSetEntry.Next() = 0;
end;
/// <summary>
/// Validates dimension combinations for a dimension set ID.
/// Checks if the dimensions in the set violate any defined dimension combination restrictions.
/// </summary>
/// <param name="DimSetID">Dimension set ID to validate combinations for</param>
/// <returns>True if dimension combinations are valid, false if violations exist</returns>
procedure CheckDimIDComb(DimSetID: Integer): Boolean
var
TempDimBuf: Record "Dimension Buffer" temporary;
begin
GetDimBufForDimSetID(DimSetID, TempDimBuf);
exit(CheckDimComb(TempDimBuf));
end;
/// <summary>
/// Validates dimension value posting permissions for specified table entities.
/// Checks default dimensions and dimension value restrictions for the given accounts and dimension set.
/// </summary>
/// <param name="TableID">Array of table IDs for accounts to validate against</param>
/// <param name="No">Array of account numbers corresponding to the table IDs</param>
/// <param name="DimSetID">Dimension set ID to validate for posting</param>
/// <returns>True if dimension values are valid for posting, false if violations exist</returns>
procedure CheckDimValuePosting(TableID: array[10] of Integer; No: array[10] of Code[20]; DimSetID: Integer): Boolean
var
DimSetEntry: Record "Dimension Set Entry";
TempDefaultDim: Record "Default Dimension" temporary;
DimValuePerAccount: Record "Dim. Value per Account";
IsHandled: Boolean;
IsChecked: Boolean;
LastErrorID: Integer;
begin
IsChecked := false;
IsHandled := false;
OnBeforeCheckDimValuePosting(TableID, No, DimSetID, IsChecked, IsHandled, DimSetEntry);
if IsHandled then
exit(IsChecked);
if not CheckBlockedDimAndValues(DimSetID) then
if not IsCollectErrorsMode then
exit(false);
LastErrorID := GetLastDimErrorID();
DimSetEntry.Reset();
DimSetEntry.SetRange("Dimension Set ID", DimSetID);
CollectDefaultDimsToCheck(TableID, No, TempDefaultDim);
TempDefaultDim.Reset();
if TempDefaultDim.FindSet() then
repeat
DimSetEntry.SetRange("Dimension Code", TempDefaultDim."Dimension Code");
IsHandled := false;
OnCheckDimValuePostingOnBeforeLogErrors(TempDefaultDim, DimSetEntry, LastErrorMessage, ErrorMessageMgt, isHandled);
if not IsHandled then begin
case TempDefaultDim."Value Posting" of
TempDefaultDim."Value Posting"::"Code Mandatory":
if not DimSetEntry.FindFirst() or (DimSetEntry."Dimension Value Code" = '') then
LogError(TempDefaultDim.RecordId, TempDefaultDim.FieldNo(TempDefaultDim."Value Posting"), GetMissedMandatoryDimErr(TempDefaultDim), '');
TempDefaultDim."Value Posting"::"Same Code":
if TempDefaultDim."Dimension Value Code" <> '' then begin
if DimSetEntry.FindFirst() then begin
if TempDefaultDim."Dimension Value Code" <> DimSetEntry."Dimension Value Code" then
LogSameCodeWrongDimErrWithSubContext(TempDefaultDim, DimSetEntry);
end
else
LogSameCodeMissingDimErrWithSubContext(TempDefaultDim, DimSetID);
end else
if DimSetEntry.FindFirst() then
LogError(TempDefaultDim.RecordId, TempDefaultDim.FieldNo(TempDefaultDim."Value Posting"), GetSameCodeBlankDimErr(TempDefaultDim), '');
TempDefaultDim."Value Posting"::"No Code":
if DimSetEntry.FindFirst() then
LogNoCodeFilledDimErrWithSubContext(TempDefaultDim, DimSetEntry);
end;
if DimValuePerAccount.Get(TempDefaultDim."Table ID", TempDefaultDim."No.", TempDefaultDim."Dimension Code", DimSetEntry."Dimension Value Code") then
if not DimValuePerAccount.Allowed then
LogError(TempDefaultDim.RecordId, TempDefaultDim.FieldNo(TempDefaultDim."Allowed Values Filter"), GetNotAllowedDimValuePerAccount(TempDefaultDim, DimSetEntry."Dimension Value Code"), '');
end;
if not IsCollectErrorsMode then
if LastErrorID <> GetLastDimErrorID() then
exit(false);
until TempDefaultDim.Next() = 0;
IsHandled := false;
OnCheckDimValuePostingOnBeforeExit(TableID, No, DimSetID, LastErrorMessage, ErrorMessageMgt, IsChecked, IsHandled);
if IsHandled then
exit(IsChecked);
exit(GetLastDimErrorID() = LastErrorID);
end;
/// <summary>
/// Validates dimension combinations within a dimension buffer.
/// Checks if the dimensions in the buffer violate any defined dimension combination restrictions.
/// </summary>
/// <param name="DimBuffer">Dimension buffer containing dimensions to validate</param>
/// <returns>True if dimension combinations are valid, false if violations exist</returns>
procedure CheckDimBuffer(var DimBuffer: Record "Dimension Buffer"): Boolean
var
TempDimBuf: Record "Dimension Buffer" temporary;
i: Integer;
begin
if DimBuffer.FindSet() then begin
i := 1;
repeat
InsertTempDimBufEntry(TempDimBuf, Database::"Dimension Buffer", i, DimBuffer."Dimension Code", DimBuffer."Dimension Value Code");
i := i + 1;
until DimBuffer.Next() = 0;
end;
exit(CheckDimComb(TempDimBuf));
end;
/// <summary>
/// Validates dimension combinations against dimension combination restrictions.
/// Core validation logic for checking dimension combination rules and generating error messages.
/// </summary>
/// <param name="TempDimBuf">Temporary dimension buffer containing dimensions to validate</param>
/// <returns>True if dimension combinations are valid, false if violations exist</returns>
procedure CheckDimComb(var TempDimBuf: Record "Dimension Buffer" temporary): Boolean
var
DimComb: Record "Dimension Combination";
CurrentDimCode: Code[20];
CurrentDimValCode: Code[20];
DimFilter: Text;
Separator: Text;
LastErrorID: Integer;
begin
OnBeforeCheckDimComb(DimComb, TempDimBuf);
if not TempDimCombInitialized then begin
TempDimCombInitialized := true;
if DimComb.IsEmpty() then
TempDimCombEmpty := true;
end;
if TempDimCombEmpty then
exit(true);
if not TempDimBuf.FindSet() then
exit(true);
repeat
DimFilter += Separator + TempDimBuf."Dimension Code";
Separator := '|';
until TempDimBuf.Next() = 0;
LastErrorID := GetLastDimErrorID();
DimComb.SetFilter("Dimension 1 Code", DimFilter);
DimComb.SetFilter("Dimension 2 Code", DimFilter);
if DimComb.FindSet() then
repeat
if DimComb."Combination Restriction" = DimComb."Combination Restriction"::Blocked then
LogError(
DimComb.RecordId, DimComb.FieldNo("Combination Restriction"),
StrSubstNo(Text000, DimComb."Dimension 1 Code", DimComb."Dimension 2 Code"), '')
else begin
TempDimBuf.SetRange("Dimension Code", DimComb."Dimension 1 Code");
TempDimBuf.FindFirst();
CurrentDimCode := TempDimBuf."Dimension Code";
CurrentDimValCode := TempDimBuf."Dimension Value Code";
TempDimBuf.SetRange("Dimension Code", DimComb."Dimension 2 Code");
TempDimBuf.FindFirst();
CheckDimValueComb(
TempDimBuf."Dimension Code", TempDimBuf."Dimension Value Code",
CurrentDimCode, CurrentDimValCode);
CheckDimValueComb(
CurrentDimCode, CurrentDimValCode,
TempDimBuf."Dimension Code", TempDimBuf."Dimension Value Code");
end;
if not IsCollectErrorsMode then
if LastErrorID <> GetLastDimErrorID() then
exit(false);
until DimComb.Next() = 0;
exit(GetLastDimErrorID() = LastErrorID);
end;
local procedure CheckDimValueComb(Dim1: Code[20]; Dim1Value: Code[20]; Dim2: Code[20]; Dim2Value: Code[20]): Boolean
var
DimValueCombination: Record "Dimension Value Combination";
IsHandled: Boolean;
begin
OnBeforeCheckDimValueComb(DimValueCombination);
if DimValueCombination.Get(Dim1, Dim1Value, Dim2, Dim2Value) then begin
IsHandled := false;
OnCheckDimValueCombOnBeforeLogError(Dim1, Dim1Value, Dim2, Dim2Value, IsHandled);
if not IsHandled then begin
LogError(
DimValueCombination.RecordId, 0, StrSubstNo(Text001, Dim1, Dim1Value, Dim2, Dim2Value), '');
exit(false);
end;
end;
exit(true);
end;
local procedure CollectDefaultDimsToCheck(TableID: array[10] of Integer; No: array[10] of Code[20]; var TempDefaultDim: Record "Default Dimension" temporary)
var
DefaultDim: Record "Default Dimension";
NoFilter: array[2] of Code[20];
i: Integer;
j: Integer;
Priority: array[2] of Integer;
begin
NoFilter[2] := '';
for i := 1 to ArrayLen(TableID) do
if (TableID[i] <> 0) and (No[i] <> '') then begin
DefaultDim.SetFilter("Value Posting", '<>%1', DefaultDim."Value Posting"::" ");
DefaultDim.SetRange("Table ID", TableID[i]);
NoFilter[1] := No[i];
for j := 1 to 2 do begin
DefaultDim.SetRange("No.", NoFilter[j]);
if DefaultDim.FindSet() then
repeat
TempDefaultDim.SetRange("Dimension Code", DefaultDim."Dimension Code");
if not TempDefaultDim.FindFirst() then begin
TempDefaultDim := DefaultDim;
TempDefaultDim.Insert();
end else begin
Priority[1] := GetDimensionPriorityForTable(TempDefaultDim."Table ID");
Priority[2] := GetDimensionPriorityForTable(DefaultDim."Table ID");
if not PriorityGreaterThan(Priority[1], Priority[2]) then begin
if PriorityGreaterThan(Priority[2], Priority[1]) then
TempDefaultDim.DeleteAll();
TempDefaultDim := DefaultDim;
if TempDefaultDim.Insert() then;
end;
end;
until DefaultDim.Next() = 0;
end;
end;
OnAfterCheckDimValuePosting(TableID, No, TempDefaultDim);
end;
local procedure PriorityGreaterThan(Priority1: Integer; Priority2: Integer): Boolean
begin
exit((Priority1 > 0) and ((Priority2 = 0) or (Priority1 < Priority2)));
end;
local procedure GetDimensionPriorityForTable(TableID: Integer): Integer
var
DefaultDimPriority: Record "Default Dimension Priority";
begin
if DefaultDimPriority.GET(SourceCode, TableID) then
exit(DefaultDimPriority.Priority);
exit(0);
end;
local procedure GetMissedMandatoryDimErr(DefaultDim: Record "Default Dimension"): Text
var
ObjectTranslation: Record "Object Translation";
DefaultDimensions: Page "Default Dimensions";
begin
if DefaultDim."No." = '' then
exit(
StrSubstNo(
DefaultDimensionsValueCodeEmptyTxt, DefaultDim."Dimension Code", DefaultDimensions.Caption));
exit(
StrSubstNo(
Text005,
DefaultDim.FieldCaption("Dimension Value Code"),
DefaultDim.FieldCaption("Dimension Code"),
DefaultDim."Dimension Code",
ObjectTranslation.TranslateTable(DefaultDim."Table ID"),
DefaultDim."No."));
end;
local procedure GetSameCodeBlankDimErr(DefaultDim: Record "Default Dimension"): Text
var
ObjectTranslation: Record "Object Translation";
begin
if DefaultDim."No." = '' then
exit(
StrSubstNo(
Text008,
DefaultDim.FieldCaption("Dimension Code"), DefaultDim."Dimension Code"));
exit(
StrSubstNo(
Text009,
DefaultDim.FieldCaption("Dimension Code"),
DefaultDim."Dimension Code",
ObjectTranslation.TranslateTable(DefaultDim."Table ID"),
DefaultDim."No."));
end;
local procedure LogSameCodeWrongDimOrNoCodeErr(DefaultDim: Record "Default Dimension"; LineDimensionValueCode: Code[20]; RequiredDimValueCode: Text[20])
var
ObjectTranslation: Record "Object Translation";
Message: Text;
begin
if DefaultDim."No." = '' then
Message := StrSubstNo(SameCodeWrongDimOrNoCode01Err, DefaultDim.FieldCaption("Dimension Value Code"), RequiredDimValueCode, DefaultDim.FieldCaption("Dimension Code"), DefaultDim."Dimension Code", LineDimensionValueCode)
else
Message := StrSubstNo(SameCodeWrongDimOrNoCode02Err, DefaultDim.FieldCaption("Dimension Value Code"), RequiredDimValueCode, DefaultDim.FieldCaption("Dimension Code"), DefaultDim."Dimension Code", ObjectTranslation.TranslateTable(DefaultDim."Table ID"), DefaultDim."No.", LineDimensionValueCode);
LogError(DefaultDim.RecordId, DefaultDim.FieldNo("Value Posting"), Message, '');
end;
local procedure LogSameCodeMissingDimErr(DefaultDim: Record "Default Dimension")
var
ObjectTranslation: Record "Object Translation";
Message: Text;
begin
if DefaultDim."No." = '' then
Message := StrSubstNo(SameCodeMissingDim01Err, DefaultDim.FieldCaption("Dimension Code"), DefaultDim."Dimension Code", DefaultDim.FieldCaption("Dimension Value Code"), DefaultDim."Dimension Value Code")
else
Message := StrSubstNo(SameCodeMissingDim02Err, DefaultDim.FieldCaption("Dimension Code"), DefaultDim."Dimension Code", DefaultDim.FieldCaption("Dimension Value Code"), DefaultDim."Dimension Value Code", ObjectTranslation.TranslateTable(DefaultDim."Table ID"), DefaultDim."No.");
LogError(DefaultDim.RecordId, DefaultDim.FieldNo("Value Posting"), Message, '');
end;
local procedure LogSameCodeWrongDimErrWithSubContext(DefaultDim: Record "Default Dimension"; DimSetEntry: Record "Dimension Set Entry")
begin
LogSameCodeWrongDimOrNoCodeErr(DefaultDim, DimSetEntry."Dimension Value Code", DefaultDim."Dimension Value Code");
ErrorMessageMgt.AddSubContextToLastErrorMessage('DimensionCodeSameError', DimSetEntry);
end;
local procedure LogSameCodeMissingDimErrWithSubContext(DefaultDim: Record "Default Dimension"; DimSetID: Integer)
begin
LogSameCodeMissingDimErr(DefaultDim);
ErrorMessageMgt.AddSubContextToLastErrorMessage('DimensionCodeSameMissingDimCodeError', DimSetID);
end;
local procedure LogNoCodeFilledDimErrWithSubContext(DefaultDim: Record "Default Dimension"; DimSetEntry: Record "Dimension Set Entry")
begin
LogSameCodeWrongDimOrNoCodeErr(DefaultDim, DimSetEntry."Dimension Value Code", BlankValueLbl);
ErrorMessageMgt.AddSubContextToLastErrorMessage('DimensionCodeMustBeBlank', DimSetEntry);
end;
/// <summary>
/// Generates error message for dimension values not allowed for specific accounts.
/// Creates appropriate error text based on whether a specific account or account type restriction applies.
/// </summary>
/// <param name="DefaultDim">Default dimension record containing the restriction rules</param>
/// <param name="DimValueCode">Dimension value code that is not allowed</param>
/// <returns>Formatted error message explaining the dimension value restriction</returns>
procedure GetNotAllowedDimValuePerAccount(DefaultDim: Record "Default Dimension"; DimValueCode: Code[20]): Text
var
ObjectTranslation: Record "Object Translation";
begin
if DefaultDim."No." = '' then
exit(
StrSubstNo(
DimValueNotAllowedForAccountTypeErr,
DefaultDim."Dimension Code",
DimValueCode,
ObjectTranslation.TranslateTable(DefaultDim."Table ID")));
exit(
StrSubstNo(
DimValueNotAllowedForAccountErr,
DefaultDim."Dimension Code",
DimValueCode,
ObjectTranslation.TranslateTable(DefaultDim."Table ID"),
DefaultDim."No."));
end;
/// <summary>
/// Retrieves the last dimension combination error message.
/// Returns the most recent error message from dimension validation operations.
/// </summary>
/// <returns>Last error message from dimension validation, empty if no errors occurred</returns>
procedure GetDimCombErr() ErrorMessage: Text[250]
begin
FindLastErrorMessage(ErrorMessage);
end;
/// <summary>
/// Updates global dimension values from default dimensions for a specific entity.
/// Retrieves default dimension values for the specified table and entity number.
/// </summary>
/// <param name="TableID">Table ID of the entity to retrieve default dimensions for</param>
/// <param name="No">Entity number to retrieve default dimensions for</param>
/// <param name="GlobalDim1Code">Variable to receive default global dimension 1 value</param>
/// <param name="GlobalDim2Code">Variable to receive default global dimension 2 value</param>
procedure UpdateDefaultDim(TableID: Integer; No: Code[20]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20])
var
DefaultDim: Record "Default Dimension";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeUpdateDefaultDim(TableID, No, GlobalDim1Code, GlobalDim2Code, IsHandled);
if not IsHandled then begin
GetGLSetup(GLSetupShortcutDimCode);
if DefaultDim.Get(TableID, No, GLSetupShortcutDimCode[1]) then
GlobalDim1Code := DefaultDim."Dimension Value Code"
else
GlobalDim1Code := '';
if DefaultDim.Get(TableID, No, GLSetupShortcutDimCode[2]) then
GlobalDim2Code := DefaultDim."Dimension Value Code"
else
GlobalDim2Code := '';
end;
OnAfterUpdateDefaultDim(TableID, No, GlobalDim1Code, GlobalDim2Code);
end;
/// <summary>
/// Creates dimension set ID from default dimension sources with priority handling and inheritance.
/// Combines dimensions from multiple sources considering default dimension priorities and inheritance rules.
/// </summary>
/// <param name="DefaultDimSource">List of dictionaries containing table IDs and their corresponding primary key values</param>
/// <param name="SourceCode">Source code to determine default dimension priorities</param>
/// <param name="GlobalDim1Code">Variable to receive global dimension 1 value</param>
/// <param name="GlobalDim2Code">Variable to receive global dimension 2 value</param>
/// <param name="InheritFromDimSetID">Dimension set ID to inherit dimensions from</param>
/// <param name="InheritFromTableNo">Table number for inheritance context</param>
/// <returns>New dimension set ID containing combined and prioritized dimensions</returns>
procedure GetDefaultDimID(DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; SourceCode: Code[20]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20]; InheritFromDimSetID: Integer; InheritFromTableNo: Integer) Result: Integer
var
DimVal: Record "Dimension Value";
DefaultDimPriority1: Record "Default Dimension Priority";
DefaultDimPriority2: Record "Default Dimension Priority";
DefaultDim: Record "Default Dimension";
TempDimBuf: Record "Dimension Buffer" temporary;
TempDimSetEntry: Record "Dimension Set Entry" temporary;
TempDimSetEntry0: Record "Dimension Set Entry" temporary;
i: Integer;
j: Integer;
NoFilter: array[2] of Code[20];
NewDimSetID: Integer;
IsHandled: Boolean;
TableIds: List of [Integer];
Nos: List of [Code[20]];
TableId: Integer;
No: Code[20];
DimSource: Dictionary of [Integer, Code[20]];
begin
IsHandled := false;
OnBeforeGetDefaultDimIDProcedure(DefaultDimSource, SourceCode, GlobalDim1Code, GlobalDim2Code, InheritFromDimSetID, InheritFromTableNo, DimVal, Result, IsHandled);
if IsHandled then
exit(Result);
GetGLSetup(GLSetupShortcutDimCode);
IsHandled := false;
OnGetDefaultDimIDOnBeforeGetInheritDimensionSet(TempDimSetEntry0, InheritFromDimSetID, InheritFromTableNo, IsHandled);
if not IsHandled then
if InheritFromDimSetID > 0 then
GetDimensionSet(TempDimSetEntry0, InheritFromDimSetID);
if TempDimSetEntry0.FindSet() then
repeat
InsertTempDimBufEntry(TempDimBuf, InheritFromTableNo, 0, TempDimSetEntry0."Dimension Code", TempDimSetEntry0."Dimension Value Code");
until TempDimSetEntry0.Next() = 0;
NoFilter[2] := '';
for i := 1 to DefaultDimSource.Count do begin
DimSource := DefaultDimSource.Get(i);
TableIds := DimSource.Keys;
Nos := DimSource.Values;
TableId := TableIds.Get(1);
No := Nos.Get(1);
if (TableId <> 0) and (No <> '') then begin
IsHandled := false;
OnGetDefaultDimOnBeforeCreate(
TempDimBuf, TableId, No, GLSetupShortcutDimCode, GlobalDim1Code, GlobalDim2Code, IsHandled, SourceCode);
if not IsHandled then begin
DefaultDim.SetRange("Table ID", TableId);
NoFilter[1] := No;
for j := 1 to 2 do begin
DefaultDim.SetRange("No.", NoFilter[j]);
if DefaultDim.FindSet() then
repeat
if DefaultDim."Dimension Value Code" <> '' then begin
TempDimBuf.SetRange("Dimension Code", DefaultDim."Dimension Code");
if not TempDimBuf.FindFirst() then
InsertTempDimBufEntry(TempDimBuf, DefaultDim."Table ID", 0, DefaultDim."Dimension Code", DefaultDim."Dimension Value Code")
else
if DefaultDimPriority1.Get(SourceCode, DefaultDim."Table ID") then begin
if DefaultDimPriority2.Get(SourceCode, TempDimBuf."Table ID") then begin
if DefaultDimPriority1.Priority < DefaultDimPriority2.Priority then begin
TempDimBuf.Delete();
InsertTempDimBufEntry(TempDimBuf, DefaultDim."Table ID", 0, DefaultDim."Dimension Code", DefaultDim."Dimension Value Code");
end;
end else begin
TempDimBuf.Delete();
InsertTempDimBufEntry(TempDimBuf, DefaultDim."Table ID", 0, DefaultDim."Dimension Code", DefaultDim."Dimension Value Code");
end;
end else
if DefDimPrioritiesNotExist(SourceCode) and (SourceCode <> '') then
if InstructionMgt.IsEnabled(InstructionMgt.DefaultDimPrioritiesCode()) then
InitializeDefaultDimPrioritiesMissingNotification(SourceCode);
if GLSetupShortcutDimCode[1] = TempDimBuf."Dimension Code" then
GlobalDim1Code := TempDimBuf."Dimension Value Code";
if GLSetupShortcutDimCode[2] = TempDimBuf."Dimension Code" then
GlobalDim2Code := TempDimBuf."Dimension Value Code";
end;
OnGetDefaultDimIDOnAfterAttributeGlobalDims(GlobalDim1Code, GlobalDim2Code);
until DefaultDim.Next() = 0;
end;
end;
end;
end;
OnGetDefaultDimIDOnBeforeFindNewDimSetIDProcedure(
TempDimBuf, DefaultDimSource, GlobalDim1Code, GlobalDim2Code, SourceCode,
GLSetupShortcutDimCode, TempDimSetEntry0, InheritFromDimSetID, InheritFromTableNo);
TempDimBuf.Reset();
if TempDimBuf.FindSet() then begin
repeat
DimVal.Get(TempDimBuf."Dimension Code", TempDimBuf."Dimension Value Code");
TempDimSetEntry."Dimension Code" := TempDimBuf."Dimension Code";
TempDimSetEntry."Dimension Value Code" := TempDimBuf."Dimension Value Code";
TempDimSetEntry."Dimension Value ID" := DimVal."Dimension Value ID";
OnGetDefaultDimIDOnBeforeTempDimSetEntryInsert(TempDimSetEntry, TempDimBuf, SourceCode);
TempDimSetEntry.Insert();
until TempDimBuf.Next() = 0;
NewDimSetID := GetDimensionSetID(TempDimSetEntry);
end;
exit(NewDimSetID);
end;
/// <summary>
/// Creates dimension set ID from default dimension sources with record context and inheritance.
/// Extended version that includes record variant context for specialized dimension handling and validation.
/// </summary>
/// <param name="RecVariant">Record variant providing context for dimension creation</param>
/// <param name="CurrFieldNo">Current field number being processed for dimension context</param>
/// <param name="DefaultDimSource">List of dictionaries containing table IDs and their corresponding primary key values</param>
/// <param name="SourceCode">Source code to determine default dimension priorities</param>
/// <param name="GlobalDim1Code">Variable to receive global dimension 1 value</param>
/// <param name="GlobalDim2Code">Variable to receive global dimension 2 value</param>
/// <param name="InheritFromDimSetID">Dimension set ID to inherit dimensions from</param>
/// <param name="InheritFromTableNo">Table number for inheritance context</param>
/// <returns>New dimension set ID containing combined and prioritized dimensions</returns>
procedure GetRecDefaultDimID(RecVariant: Variant; CurrFieldNo: Integer; DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; SourceCode: Code[20]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20]; InheritFromDimSetID: Integer; InheritFromTableNo: Integer) Result: Integer
var
DefaultDimID: Integer;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeGetRecDefaultDimID(RecVariant, CurrFieldNo, DefaultDimSource, SourceCode, InheritFromDimSetID, InheritFromTableNo, Result, IsHandled);
if IsHandled then
exit(Result);
DefaultDimID := GetDefaultDimID(DefaultDimSource, SourceCode, GlobalDim1Code, GlobalDim2Code, InheritFromDimSetID, InheritFromTableNo);
OnAfterGetRecDefaultDimIDProcedure(RecVariant, CurrFieldNo, DefaultDimSource, SourceCode, InheritFromDimSetID, InheritFromTableNo, GlobalDim1Code, GlobalDim2Code, DefaultDimID);
exit(DefaultDimID);
end;
/// <summary>
/// Adds a new table ID and number pair to the beginning of the arrays, shifting existing entries.
/// Inserts the new entry at position 1 and moves all other entries one position down.
/// </summary>
/// <param name="TableID">Array of table IDs to modify</param>
/// <param name="No">Array of entity numbers corresponding to the table IDs</param>
/// <param name="NewTableId">New table ID to insert at the beginning</param>
/// <param name="NewNo">New entity number to insert at the beginning</param>
procedure AddFirstToTableIdArray(var TableID: array[10] of Integer; var No: array[10] of Code[20]; NewTableId: Integer; NewNo: Code[20])
var
Index: Integer;
begin
if NewNo = '' then
exit;
for Index := ArrayLen(TableID) downto 2 do begin
TableID[Index] := TableID[Index - 1];
No[Index] := No[Index - 1];
end;
TableID[1] := NewTableId;
No[1] := NewNo;
end;
/// <summary>
/// Adds a new table ID and number pair to the end of the arrays.
/// Finds the first empty position or uses the last position to insert the new entry.
/// </summary>
/// <param name="TableID">Array of table IDs to modify</param>
/// <param name="No">Array of entity numbers corresponding to the table IDs</param>
/// <param name="NewTableId">New table ID to insert at the end</param>
/// <param name="NewNo">New entity number to insert at the end</param>
procedure AddLastToTableIdArray(var TableID: array[10] of Integer; var No: array[10] of Code[20]; NewTableId: Integer; NewNo: Code[20])
var
Index: Integer;
begin
if NewNo = '' then
exit;
for Index := 1 to ArrayLen(TableID) do
if (No[Index] = '') or (Index = ArrayLen(TableID)) then begin
TableID[Index] := NewTableId;
No[Index] := NewNo;
exit;
end;
end;
/// <summary>
/// Converts an entity type option to its corresponding table ID for dimension processing.
/// Maps common master data types to their table IDs for default dimension handling.
/// </summary>
/// <param name="Type">Entity type option containing G/L Account, Customer, Vendor, Bank Account, Fixed Asset, IC Partner, or Employee</param>
/// <returns>Table ID corresponding to the specified entity type</returns>
procedure TypeToTableID1(Type: Option "G/L Account",Customer,Vendor,"Bank Account","Fixed Asset","IC Partner",Employee) TableId: Integer
begin
case Type of
Type::"G/L Account":
exit(Database::"G/L Account");
Type::Customer:
exit(Database::Customer);
Type::Vendor:
exit(Database::Vendor);
Type::Employee:
exit(Database::Employee);
Type::"Bank Account":
exit(Database::"Bank Account");
Type::"Fixed Asset":
exit(Database::"Fixed Asset");
Type::"IC Partner":
exit(Database::"IC Partner");
end;
OnAfterTypeToTableID1(Type, TableId);
end;
/// <summary>
/// Converts a resource/item type option to its corresponding table ID for dimension processing.
/// Maps resource, item, and G/L account types to their table IDs for default dimension handling.
/// </summary>
/// <param name="Type">Entity type option containing Resource, Item, or G/L Account</param>
/// <returns>Table ID corresponding to the specified entity type</returns>
procedure TypeToTableID2(Type: Option Resource,Item,"G/L Account"): Integer
var
TableID: Integer;
begin
case Type of
Type::Resource:
exit(Database::Resource);
Type::Item:
exit(Database::Item);
Type::"G/L Account":
exit(Database::"G/L Account");
else begin
OnTypeToTableID2(TableID, Type);
exit(TableID);
end;
end;
end;
/// <summary>
/// Converts a sales line type enum to its corresponding table ID for dimension processing.
/// Maps sales line types to their master data table IDs for default dimension handling.
/// </summary>
/// <param name="LineType">Sales line type enum specifying the type of line item</param>
/// <returns>Table ID corresponding to the specified sales line type, zero for blank lines</returns>
procedure SalesLineTypeToTableID(LineType: Enum "Sales Line Type") TableId: Integer
begin
case LineType of
"Sales Line Type"::" ":
exit(0);
"Sales Line Type"::"G/L Account":
exit(Database::"G/L Account");
"Sales Line Type"::Item:
exit(Database::Item);
"Sales Line Type"::Resource:
exit(Database::Resource);
"Sales Line Type"::"Fixed Asset":
exit(Database::"Fixed Asset");
"Sales Line Type"::"Charge (Item)":
exit(Database::"Item Charge");
end;
OnAfterSalesLineTypeToTableID(LineType, TableId);
end;
/// <summary>
/// Converts a purchase line type enum to its corresponding table ID for dimension processing.
/// Maps purchase line types to their master data table IDs for default dimension handling.
/// </summary>
/// <param name="LineType">Purchase line type enum specifying the type of line item</param>
/// <returns>Table ID corresponding to the specified purchase line type, zero for blank lines</returns>
procedure PurchLineTypeToTableID(LineType: Enum "Purchase Line Type") TableId: Integer
begin
case LineType of
"Purchase Line Type"::" ":
exit(0);
"Purchase Line Type"::"G/L Account":
exit(Database::"G/L Account");
"Purchase Line Type"::Item:
exit(Database::Item);
"Purchase Line Type"::Resource:
exit(Database::Resource);
"Purchase Line Type"::"Fixed Asset":
exit(Database::"Fixed Asset");
"Purchase Line Type"::"Charge (Item)":
exit(Database::"Item Charge");
end;
OnAfterPurchLineTypeToTableID(LineType, TableId);
end;
/// <summary>
/// Converts a requisition line type enum to its corresponding table ID for dimension processing.
/// Maps requisition line types to their master data table IDs for default dimension handling.
/// </summary>
/// <param name="LineType">Requisition line type enum specifying the type of line item</param>
/// <returns>Table ID corresponding to the specified requisition line type, zero for blank lines</returns>
procedure ReqLineTypeToTableID(LineType: Enum "Requisition Line Type") TableId: Integer
begin
case LineType of
"Requisition Line Type"::" ":
exit(0);
"Requisition Line Type"::"G/L Account":
exit(Database::"G/L Account");
"Requisition Line Type"::Item:
exit(Database::Item);
end;
OnAfterReqLineTypeToTableID(LineType, TableId);
end;
/// <summary>
/// Converts a basic item/resource type option to its corresponding table ID for dimension processing.
/// Maps item and resource types to their table IDs for default dimension handling.
/// </summary>
/// <param name="Type">Type option containing blank, Item, or Resource</param>
/// <returns>Table ID corresponding to the specified type, zero for blank type</returns>
procedure TypeToTableID4(Type: Option " ",Item,Resource) TableId: Integer
begin
case Type of
Type::" ":
exit(0);
Type::Item:
exit(Database::Item);
Type::Resource:
exit(Database::Resource);
end;
OnAfterTypeToTableID4(Type, TableId);
end;
/// <summary>
/// Deletes all default dimensions for a specific table and record number.
/// </summary>
/// <param name="TableID">ID of the table to delete default dimensions for</param>
/// <param name="No">Record number to delete default dimensions for</param>
procedure DeleteDefaultDim(TableID: Integer; No: Code[20])
var
DefaultDim: Record "Default Dimension";
begin
DefaultDim.SetRange("Table ID", TableID);
DefaultDim.SetRange("No.", No);
if not DefaultDim.IsEmpty() then
DefaultDim.DeleteAll();
OnAfterDeleteDefaultDim(TableID, No);
end;
/// <summary>
/// Renames default dimensions from old record number to new record number for a specific table.
/// </summary>
/// <param name="TableID">ID of the table containing the records being renamed</param>
/// <param name="OldNo">Original record number with default dimensions</param>
/// <param name="NewNo">New record number to transfer default dimensions to</param>
procedure RenameDefaultDim(TableID: Integer; OldNo: Code[20]; NewNo: Code[20])
var
DefaultDim: Record "Default Dimension";
DefaultDimToRename: Record "Default Dimension";
begin
DefaultDim.SetRange("Table ID", TableID);
DefaultDim.SetRange("No.", OldNo);
if DefaultDim.FindSet(true) then
repeat
DefaultDimToRename := DefaultDim;
DefaultDimToRename.Rename(DefaultDim."Table ID", NewNo, DefaultDim."Dimension Code");
until DefaultDim.Next() = 0;
end;
/// <summary>
/// Opens a lookup window for dimension values for a specific shortcut dimension field.
/// </summary>
/// <param name="FieldNumber">Shortcut dimension field number (1-8) to lookup values for</param>
/// <param name="ShortcutDimCode">Dimension value code that will be set if user selects a value</param>
procedure LookupDimValueCode(FieldNumber: Integer; var ShortcutDimCode: Code[20])
var
DimVal: Record "Dimension Value";
GLSetup: Record "General Ledger Setup";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeLookupDimValueCode(FieldNumber, ShortcutDimCode, IsHandled);
if IsHandled then
exit;
GetGLSetup(GLSetupShortcutDimCode);
if GLSetupShortcutDimCode[FieldNumber] = '' then
Error(ShortcutDimensionNotDefinedErr, GLSetup.TableCaption(), FieldNumber);
DimVal.SetRange("Dimension Code", GLSetupShortcutDimCode[FieldNumber]);
DimVal."Dimension Code" := GLSetupShortcutDimCode[FieldNumber];
DimVal.Code := ShortcutDimCode;
OnLookupDimValueCodeOnBeforeDimValRunModal(DimVal, FieldNumber);
if PAGE.RunModal(0, DimVal) = ACTION::LookupOK then begin
CheckDim(DimVal."Dimension Code");
CheckDimValue(DimVal."Dimension Code", DimVal.Code);
ShortcutDimCode := DimVal.Code;
end;
end;
/// <summary>
/// Validates a dimension value code for a specific shortcut dimension field and resolves partial matches.
/// </summary>
/// <param name="FieldNumber">Shortcut dimension field number (1-8) to validate for</param>
/// <param name="ShortcutDimCode">Dimension value code to validate; may be updated with exact match</param>
procedure ValidateDimValueCode(FieldNumber: Integer; var ShortcutDimCode: Code[20])
var
DimVal: Record "Dimension Value";
GLSetup: Record "General Ledger Setup";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeValidateDimValueCode(FieldNumber, ShortcutDimCode, IsHandled, GLSetupShortcutDimCode, DimVal);
if not IsHandled then begin
GetGLSetup(GLSetupShortcutDimCode);
if (GLSetupShortcutDimCode[FieldNumber] = '') and (ShortcutDimCode <> '') then
Error(ShortcutDimensionNotDefinedErr, GLSetup.TableCaption(), FieldNumber);
DimVal.SetRange("Dimension Code", GLSetupShortcutDimCode[FieldNumber]);
if ShortcutDimCode <> '' then begin
DimVal.SetRange(Code, ShortcutDimCode);
if not DimVal.FindFirst() then begin
DimVal.SetFilter(Code, StrSubstNo('%1*', ShortcutDimCode));
if DimVal.FindFirst() then
ShortcutDimCode := DimVal.Code
else
Error(
Text003,
ShortcutDimCode, DimVal.FieldCaption(Code));
end;
end;
end;
OnAfterValidateDimValueCode(FieldNumber, ShortcutDimCode, GLSetupShortcutDimCode, DimVal);
end;
/// <summary>
/// Validates a shortcut dimension value and updates the dimension set ID with the new value.
/// </summary>
/// <param name="FieldNumber">Shortcut dimension field number (1-8) to validate</param>
/// <param name="ShortcutDimCode">Dimension value code to validate and set</param>
/// <param name="DimSetID">Dimension set ID to update with the validated dimension value</param>
procedure ValidateShortcutDimValues(FieldNumber: Integer; var ShortcutDimCode: Code[20]; var DimSetID: Integer)
var
DimVal: Record "Dimension Value";
TempDimSetEntry: Record "Dimension Set Entry" temporary;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeValidateShortcutDimValues(DimVal, FieldNumber, ShortcutDimCode, DimSetID, IsHandled);
if IsHandled then
exit;
ValidateDimValueCode(FieldNumber, ShortcutDimCode);
DimVal."Dimension Code" := GLSetupShortcutDimCode[FieldNumber];
if ShortcutDimCode <> '' then begin
DimVal.Get(DimVal."Dimension Code", ShortcutDimCode);
if not CheckDim(DimVal."Dimension Code") then
Error(GetDimErr());
if not CheckDimValue(DimVal."Dimension Code", ShortcutDimCode) then
Error(GetDimErr());
end;
GetDimensionSet(TempDimSetEntry, DimSetID);
if TempDimSetEntry.Get(TempDimSetEntry."Dimension Set ID", DimVal."Dimension Code") then
if TempDimSetEntry."Dimension Value Code" <> ShortcutDimCode then
TempDimSetEntry.Delete();
if ShortcutDimCode <> '' then begin
TempDimSetEntry."Dimension Code" := DimVal."Dimension Code";
TempDimSetEntry."Dimension Value Code" := DimVal.Code;
TempDimSetEntry."Dimension Value ID" := DimVal."Dimension Value ID";
if TempDimSetEntry.Insert() then;
end;
DimSetID := GetDimensionSetID(TempDimSetEntry);
OnAfterValidateShortcutDimValues(FieldNumber, ShortcutDimCode, DimSetID);
end;
/// <summary>
/// Saves a default dimension value for a specific table record and shortcut dimension field.
/// </summary>
/// <param name="TableID">ID of the table to save default dimension for</param>
/// <param name="No">Record number to save default dimension for</param>
/// <param name="FieldNumber">Shortcut dimension field number (1-8) to save</param>
/// <param name="ShortcutDimCode">Dimension value code to save as default; empty value deletes existing default</param>
procedure SaveDefaultDim(TableID: Integer; No: Code[20]; FieldNumber: Integer; ShortcutDimCode: Code[20])
var
DefaultDim: Record "Default Dimension";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeSaveDefaultDim(TableID, No, FieldNumber, ShortcutDimCode, IsHandled);
if IsHandled then
exit;
GetGLSetup(GLSetupShortcutDimCode);
if ShortcutDimCode <> '' then begin
if DefaultDim.Get(TableID, No, GLSetupShortcutDimCode[FieldNumber])
then begin
DefaultDim.Validate("Dimension Value Code", ShortcutDimCode);
DefaultDim.Modify();
end else begin
DefaultDim.Init();
DefaultDim.Validate("Table ID", TableID);
DefaultDim.Validate("No.", No);
DefaultDim.Validate("Dimension Code", GLSetupShortcutDimCode[FieldNumber]);
DefaultDim.Validate("Dimension Value Code", ShortcutDimCode);
DefaultDim.Insert();
end;
end else
if DefaultDim.Get(TableID, No, GLSetupShortcutDimCode[FieldNumber]) then
DefaultDim.Delete();
end;
/// <summary>
/// Retrieves global dimension values for all 8 shortcut dimension fields from a dimension set.
/// </summary>
/// <param name="DimSetID">Dimension set ID to retrieve values from</param>
/// <param name="ShortcutDimCode">Array to populate with dimension values for fields 1-8</param>
procedure GetGlobalDimensions(DimSetID: Integer; var ShortcutDimCode: array[8] of Code[20])
var
GetShortcutDimensionValues: Codeunit "Get Shortcut Dimension Values";
begin
GetShortcutDimensionValues.GetGlobalDimensions(DimSetID, ShortcutDimCode);
end;
/// <summary>
/// Retrieves shortcut dimension values for all 8 fields from a dimension set.
/// </summary>
/// <param name="DimSetID">Dimension set ID to retrieve values from</param>
/// <param name="ShortcutDimCode">Array to populate with dimension values for fields 1-8</param>
procedure GetShortcutDimensions(DimSetID: Integer; var ShortcutDimCode: array[8] of Code[20])
var
GetShortcutDimensionValues: Codeunit "Get Shortcut Dimension Values";
begin
GetShortcutDimensionValues.GetShortcutDimensions(DimSetID, ShortcutDimCode);
end;
/// <summary>
/// Validates dimension buffer values against posting restrictions and default dimension rules.
/// </summary>
/// <param name="DimBuffer">Dimension buffer containing values to validate</param>
/// <param name="TableID">Array of table IDs to check default dimension rules for</param>
/// <param name="No">Array of record numbers corresponding to table IDs</param>
/// <returns>True if all dimension values are valid for posting, false otherwise</returns>
procedure CheckDimBufferValuePosting(var DimBuffer: Record "Dimension Buffer"; TableID: array[10] of Integer; No: array[10] of Code[20]): Boolean
var
TempDimBuf: Record "Dimension Buffer" temporary;
i: Integer;
begin
if DimBuffer.FindSet() then begin
i := 1;
repeat
if (not CheckDimValue(
DimBuffer."Dimension Code", DimBuffer."Dimension Value Code")) or
(not CheckDim(DimBuffer."Dimension Code"))
then
exit(false);
TempDimBuf.Init();
TempDimBuf."Entry No." := i;
TempDimBuf."Dimension Code" := DimBuffer."Dimension Code";
TempDimBuf."Dimension Value Code" := DimBuffer."Dimension Value Code";
TempDimBuf.Insert();
i := i + 1;
until DimBuffer.Next() = 0;
end;
exit(CheckValuePosting(TableID, No, TempDimBuf));
end;
local procedure CheckValuePosting(TableID: array[10] of Integer; No: array[10] of Code[20]; var TempDimBuf: Record "Dimension Buffer" temporary): Boolean
var
DefaultDim: Record "Default Dimension";
i: Integer;
j: Integer;
NoFilter: array[2] of Text[250];
IsChecked: Boolean;
IsHandled: Boolean;
begin
IsChecked := false;
IsHandled := false;
OnBeforeCheckValuePosting(TableID, No, TempDimBuf, IsChecked, IsHandled);
if IsHandled then
exit(IsChecked);
DefaultDim.SetFilter("Value Posting", '<>%1', DefaultDim."Value Posting"::" ");
NoFilter[2] := '';
for i := 1 to ArrayLen(TableID) do
if (TableID[i] <> 0) and (No[i] <> '') then begin
DefaultDim.SetRange("Table ID", TableID[i]);
NoFilter[1] := No[i];
for j := 1 to 2 do begin
DefaultDim.SetRange("No.", NoFilter[j]);
if DefaultDim.FindSet() then begin
repeat
TempDimBuf.SetRange("Dimension Code", DefaultDim."Dimension Code");
case DefaultDim."Value Posting" of
DefaultDim."Value Posting"::"Code Mandatory":
if (not TempDimBuf.FindFirst()) or (TempDimBuf."Dimension Value Code" = '') then begin
LogError(
DefaultDim.RecordId, DefaultDim.FieldNo("Value Posting"), GetMissedMandatoryDimErr(DefaultDim), '');
exit(false);
end;
DefaultDim."Value Posting"::"Same Code":
if DefaultDim."Dimension Value Code" <> '' then
if TempDimBuf.FindFirst() then begin
if DefaultDim."Dimension Value Code" <> TempDimBuf."Dimension Value Code" then begin
LogSameCodeWrongDimOrNoCodeErr(DefaultDim, TempDimBuf."Dimension Value Code", DefaultDim."Dimension Value Code");
exit(false);
end;
end
else begin
LogSameCodeMissingDimErr(DefaultDim);
exit(false);
end
else
if TempDimBuf.FindFirst() then begin
LogError(
DefaultDim.RecordId, DefaultDim.FieldNo("Value Posting"), GetSameCodeBlankDimErr(DefaultDim), '');
exit(false);
end;
DefaultDim."Value Posting"::"No Code":
if TempDimBuf.FindFirst() then begin
LogSameCodeWrongDimOrNoCodeErr(DefaultDim, TempDimBuf."Dimension Value Code", BlankValueLbl);
exit(false);
end;
end;
OnCheckValuePostingOnAfterDefaultDimLoop(TempDimBuf, DefaultDim);
until DefaultDim.Next() = 0;
TempDimBuf.Reset();
end;
end;
end;
OnCheckValuePostingOnBeforeExit(TableID, No, TempDimBuf, LastErrorMessage, ErrorMessageMgt, IsChecked, IsHandled);
if IsHandled then
exit(IsChecked);
exit(true);
end;
/// <summary>
/// Retrieves the last dimension value posting error message.
/// </summary>
/// <returns>Error message text describing the dimension value posting issue</returns>
procedure GetDimValuePostingErr() ErrorMessage: Text[250]
begin
FindLastErrorMessage(ErrorMessage);
end;
/// <summary>
/// Populates a temporary table with object numbers that support default dimensions.
/// </summary>
/// <param name="TempAllObjWithCaption">Temporary record to populate with objects that can have default dimensions</param>
procedure DefaultDimObjectNoList(var TempAllObjWithCaption: Record AllObjWithCaption temporary)
begin
DefaultDimObjectNoWithoutGlobalDimsList(TempAllObjWithCaption);
DefaultDimObjectNoWithGlobalDimsList(TempAllObjWithCaption);
OnAfterDefaultDimObjectNoList(TempAllObjWithCaption);
end;
/// <summary>
/// Populates a temporary table with object numbers that support default dimensions and have global dimensions.
/// </summary>
/// <param name="TempAllObjWithCaption">Temporary record to populate with objects that can have default dimensions with global dimension support</param>
procedure DefaultDimObjectNoWithGlobalDimsList(var TempAllObjWithCaption: Record AllObjWithCaption temporary)
var
TempDimField: Record "Field" temporary;
TempDimSetIDField: Record "Field" temporary;
begin
TempDimField.SetFilter(
TableNo, '<>%1&<>%2&<>%3',
Database::"General Ledger Setup", Database::"Job Task", Database::"Change Global Dim. Header");
TempDimField.SetFilter(ObsoleteState, '<>%1', TempDimField.ObsoleteState::Removed);
TempDimField.SetFilter(FieldName, '*Global Dimension*');
TempDimField.SetRange(Type, TempDimField.Type::Code);
TempDimField.SetRange(Len, 20);
FillNormalFieldBuffer(TempDimField);
TempDimSetIDField.SetRange(RelationTableNo, Database::"Dimension Set Entry");
FillNormalFieldBuffer(TempDimSetIDField);
OnBeforeSetupObjectNoList(TempDimField);
if TempDimField.FindSet() then
repeat
TempDimSetIDField.SetRange(TableNo, TempDimField.TableNo);
if TempDimSetIDField.IsEmpty() then
DefaultDimInsertTempObject(TempAllObjWithCaption, TempDimField.TableNo);
until TempDimField.Next() = 0;
OnAfterSetupObjectNoList(TempAllObjWithCaption);
end;
local procedure DefaultDimObjectNoWithoutGlobalDimsList(var TempAllObjWithCaption: Record AllObjWithCaption temporary)
begin
DefaultDimInsertTempObject(TempAllObjWithCaption, Database::"IC Partner");
DefaultDimInsertTempObject(TempAllObjWithCaption, Database::Location);
OnAfterDefaultDimObjectNoWithoutGlobalDimsList(TempAllObjWithCaption);
end;
/// <summary>
/// Inserts a temporary object record for tables that support default dimensions.
/// </summary>
/// <param name="TempAllObjWithCaption">Temporary record to insert the object information into</param>
/// <param name="TableID">Table ID to check and insert if it supports default dimensions</param>
procedure DefaultDimInsertTempObject(var TempAllObjWithCaption: Record AllObjWithCaption temporary; TableID: Integer)
begin
if IsObsolete(TableID) then
exit;
if KeyContainsOneCodeField(TableID) or IsDefaultDimTable(TableID) then
InsertObject(TempAllObjWithCaption, TableID);
end;
local procedure IsDefaultDimTable(TableID: Integer) Result: Boolean
begin
// Local versions should add exceptions here
Result := TableID = 0;
OnAfterIsDefaultDimTable(TableID, Result);
end;
local procedure KeyContainsOneCodeField(TableID: Integer) Result: Boolean
var
FieldRef: FieldRef;
KeyRef: KeyRef;
RecRef: RecordRef;
begin
RecRef.Open(TableID);
KeyRef := RecRef.KeyIndex(1);
FieldRef := KeyRef.FieldIndex(1);
Result := (KeyRef.FieldCount = 1) and (FieldRef.Type = FieldType::Code);
RecRef.Close();
end;
/// <summary>
/// Populates a temporary table with object numbers that support global dimensions.
/// </summary>
/// <param name="TempAllObjWithCaption">Temporary record to populate with objects that support global dimension fields</param>
procedure GlobalDimObjectNoList(var TempAllObjWithCaption: Record AllObjWithCaption temporary)
var
"Field": Record "Field";
TempDimField: Record "Field" temporary;
TempDimSetIDField: Record "Field" temporary;
LastTableNo: Integer;
begin
TempDimSetIDField.SetRange(RelationTableNo, Database::"Dimension Set Entry");
FillNormalFieldBuffer(TempDimSetIDField);
TempDimField.SetFilter(FieldName, '*Global Dimension*|*Shortcut Dimension*|*Global Dim.*');
TempDimField.SetFilter(ObsoleteState, '<>%1', TempDimField.ObsoleteState::Removed);
TempDimField.SetRange(Type, TempDimField.Type::Code);
TempDimField.SetRange(Len, 20);
FillNormalFieldBuffer(TempDimField);
TempDimField.Reset();
if TempDimSetIDField.FindSet() then
repeat
TempDimField.SetRange(TableNo, TempDimSetIDField.TableNo);
if not TempDimField.IsEmpty() then begin
InsertObject(TempAllObjWithCaption, TempDimSetIDField.TableNo);
TempDimField.DeleteAll();
end;
until TempDimSetIDField.Next() = 0;
TempDimField.Reset();
TempDimField.SetFilter(ObsoleteState, '<>%1', TempDimField.ObsoleteState::Removed);
TempDimField.SetFilter(FieldName, '*Global Dim.*');
if TempDimField.FindSet() then
repeat
if LastTableNo <> TempDimField.TableNo then begin
LastTableNo := TempDimField.TableNo;
// Field No. 2 must relate to a table with Dim Set ID
if Field.Get(TempDimField.TableNo, 2) then begin
TempDimSetIDField.SetRange(TableNo, Field.RelationTableNo);
if not TempDimSetIDField.IsEmpty() then
InsertObject(TempAllObjWithCaption, TempDimField.TableNo);
end;
end;
until TempDimField.Next() = 0;
end;
/// <summary>
/// Populates a temporary table with job task object numbers that support dimensions.
/// </summary>
/// <param name="TempAllObjWithCaption">Temporary record to populate with job task objects that support dimension handling</param>
procedure JobTaskDimObjectNoList(var TempAllObjWithCaption: Record AllObjWithCaption temporary)
begin
// Table 1001 "Job Task" is an exception
// it has Table 1002 "Job Task Dimension" that implements default dimension behavior
InsertObject(TempAllObjWithCaption, Database::"Job Task");
end;
/// <summary>
/// Searches for dimension fields in a specific table using a field name filter.
/// </summary>
/// <param name="TableNo">Table number to search for dimension fields</param>
/// <param name="FieldNameFilter">Filter text to match against field names</param>
/// <param name="Field">Field record that will contain the found dimension field</param>
/// <returns>True if a dimension field matching the filter is found, false otherwise</returns>
procedure FindDimFieldInTable(TableNo: Integer; FieldNameFilter: Text; var "Field": Record "Field"): Boolean
begin
if IsObsolete(TableNo) then
exit(false);
Field.SetRange(TableNo, TableNo);
Field.SetFilter(FieldName, '*' + FieldNameFilter + '*');
Field.SetFilter(ObsoleteState, '<>%1', Field.ObsoleteState::Removed);
Field.SetRange(Class, Field.Class::Normal);
Field.SetRange(Type, Field.Type::Code);
Field.SetRange(Len, 20);
if Field.FindFirst() then
exit(true);
end;
local procedure FillNormalFieldBuffer(var TempField: Record "Field")
var
"Field": Record "Field";
begin
Field.CopyFilters(TempField);
Field.SetRange(Class, Field.Class::Normal);
Field.SetFilter(ObsoleteState, '<>%1', Field.ObsoleteState::Removed);
if Field.FindSet() then
repeat
if not IsObsolete(Field.TableNo) then begin
TempField := Field;
TempField.Insert();
end;
until Field.Next() = 0;
end;
/// <summary>
/// Retrieves the last document dimension consistency error message.
/// </summary>
/// <returns>Error message text describing the document dimension consistency issue</returns>
procedure GetDocDimConsistencyErr() ErrorMessage: Text[250]
begin
FindLastErrorMessage(ErrorMessage);
end;
/// <summary>
/// Validates that a dimension code exists and is not blocked.
/// </summary>
/// <param name="DimCode">Dimension code to validate</param>
/// <returns>True if the dimension is valid and not blocked, false otherwise</returns>
procedure CheckDim(DimCode: Code[20]): Boolean
var
Dim: Record Dimension;
IsHandled: Boolean;
Result: Boolean;
begin
IsHandled := false;
OnBeforeCheckDim(DimCode, Result, IsHandled, Dim);
if IsHandled then
exit(Result);
if Dim.Get(DimCode) then begin
if Dim.Blocked then begin
LogError(
Dim.RecordId, Dim.FieldNo(Blocked), StrSubstNo(Text014, Dim.TableCaption(), DimCode), '');
exit(false);
end;
end else begin
LogError(
Database::Dimension, 0, StrSubstNo(Text015, Dim.TableCaption(), DimCode), '');
exit(false);
end;
exit(true);
end;
/// <summary>
/// Validates that a dimension value exists and is not blocked for the specified dimension.
/// </summary>
/// <param name="DimCode">Dimension code to validate the value against</param>
/// <param name="DimValCode">Dimension value code to validate</param>
/// <returns>True if the dimension value is valid and not blocked, false otherwise</returns>
procedure CheckDimValue(DimCode: Code[20]; DimValCode: Code[20]) Result: Boolean
var
DimVal: Record "Dimension Value";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckDimValue(DimCode, DimValCode, Result, IsHandled, DimVal);
if not IsHandled then begin
if (DimCode <> '') and (DimValCode <> '') then
if DimVal.Get(DimCode, DimValCode) then begin
IsHandled := false;
OnCheckDimValueOnBeforeCheckDimValBlocked(DimCode, DimValCode, Result, IsHandled, DimVal);
if not IsHandled then
if DimVal.Blocked then begin
LogError(
DimVal.RecordId, DimVal.FieldNo(Blocked),
StrSubstNo(DimValueBlockedErr, DimVal.TableCaption(), DimCode, DimValCode), '');
exit(false);
end;
if not CheckDimValueAllowed(DimVal) then
exit(false);
end else begin
LogError(
Database::"Dimension Value", 0,
StrSubstNo(DimValueMissingErr, DimVal.TableCaption(), DimCode, DimValCode), '');
exit(false);
end;
Result := true;
end;
OnAfterCheckDimValue(DimCode, DimValCode, Result);
end;
local procedure CheckDimValueAllowed(DimVal: Record "Dimension Value") Result: Boolean
var
DimValueAllowed: Boolean;
DimErr: Text[250];
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckDimValueAllowed(DimVal, IsHandled, Result);
if IsHandled then
exit(Result);
DimValueAllowed :=
(DimVal."Dimension Value Type" in [DimVal."Dimension Value Type"::Standard, DimVal."Dimension Value Type"::"Begin-Total"]);
if not DimValueAllowed then
DimErr :=
StrSubstNo(
DimValueMustNotBeErr, DimVal.TableCaption(), DimVal."Dimension Code", DimVal.Code, Format(DimVal."Dimension Value Type"))
else
OnCheckDimValueAllowed(DimVal, DimValueAllowed, DimErr);
if not DimValueAllowed then
LogError(DimVal.RecordId, DimVal.FieldNo("Dimension Value Type"), DimErr, '');
exit(DimValueAllowed);
end;
/// <summary>
/// Validates that dimensions and dimension values in a dimension set are not blocked.
/// </summary>
/// <param name="DimSetID">Dimension set ID to validate for blocked dimensions and values</param>
/// <returns>True if no blocked dimensions or values are found, false otherwise</returns>
procedure CheckBlockedDimAndValues(DimSetID: Integer): Boolean
var
DimSetEntry: Record "Dimension Set Entry";
LastErrorID: Integer;
begin
if DimSetID = 0 then
exit(true);
LastErrorID := GetLastDimErrorID();
DimSetEntry.Reset();
DimSetEntry.SetRange("Dimension Set ID", DimSetID);
if DimSetEntry.FindSet() then
repeat
if not CheckDim(DimSetEntry."Dimension Code") or
not CheckDimValue(DimSetEntry."Dimension Code", DimSetEntry."Dimension Value Code")
then
if not IsCollectErrorsMode then
exit(false);
until DimSetEntry.Next() = 0;
exit(GetLastDimErrorID() = LastErrorID);
end;
/// <summary>
/// Retrieves the last dimension error message.
/// </summary>
/// <returns>Error message text describing the dimension validation issue</returns>
procedure GetDimErr() ErrorMessage: Text[250]
begin
FindLastErrorMessage(ErrorMessage);
end;
/// <summary>
/// Logs a dimension error for a specific source record and field.
/// </summary>
/// <param name="SourceRecVariant">Source record variant where the error occurred</param>
/// <param name="SourceFieldNo">Field number where the error occurred</param>
/// <param name="Message">Error message to log</param>
/// <param name="HelpArticleCode">Help article code for additional guidance</param>
/// <returns>True if the error was successfully logged, false otherwise</returns>
procedure LogError(SourceRecVariant: Variant; SourceFieldNo: Integer; Message: Text; HelpArticleCode: Code[30]) IsLogged: Boolean
var
ForwardLinkMgt: Codeunit "Forward Link Mgt.";
begin
if ErrorMessageMgt.IsActive() then begin
if HelpArticleCode = '' then
HelpArticleCode := ForwardLinkMgt.GetHelpCodeForWorkingWithDimensions();
ErrorMessageMgt.LogContextFieldError(0, Message, SourceRecVariant, SourceFieldNo, HelpArticleCode);
IsLogged := true;
end else begin
LastErrorMessage.Init();
LastErrorMessage.ID += 1;
LastErrorMessage."Message" := CopyStr(Message, 1, MaxStrLen(LastErrorMessage."Message"));
IsLogged := false;
end;
end;
/// <summary>
/// Opens dimension value lookup dialog for a specified shortcut dimension field without updating the source record.
/// Validates that the shortcut dimension is properly configured before showing the lookup.
/// </summary>
/// <param name="FieldNumber">Shortcut dimension field number (1-8) to lookup values for</param>
procedure LookupDimValueCodeNoUpdate(FieldNumber: Integer)
var
DimVal: Record "Dimension Value";
GLSetup: Record "General Ledger Setup";
begin
OnBeforeLookupDimValueCodeNoUpdate(FieldNumber);
GetGLSetup(GLSetupShortcutDimCode);
if GLSetupShortcutDimCode[FieldNumber] = '' then
Error(ShortcutDimensionNotDefinedErr, GLSetup.TableCaption(), FieldNumber);
DimVal.SetRange("Dimension Code", GLSetupShortcutDimCode[FieldNumber]);
if PAGE.RunModal(0, DimVal) = ACTION::LookupOK then;
end;
/// <summary>
/// Copies dimension set entries from journal lines to intercompany journal line dimensions.
/// Converts company-specific dimension codes to intercompany dimension codes during the copy process.
/// </summary>
/// <param name="TableID">Source table identifier for the journal line</param>
/// <param name="TransactionNo">Intercompany transaction number</param>
/// <param name="PartnerCode">Intercompany partner code</param>
/// <param name="TransactionSource">Source of the intercompany transaction</param>
/// <param name="LineNo">Line number within the transaction</param>
/// <param name="DimSetID">Dimension set ID containing dimensions to copy</param>
procedure CopyJnlLineDimToICJnlDim(TableID: Integer; TransactionNo: Integer; PartnerCode: Code[20]; TransactionSource: Option; LineNo: Integer; DimSetID: Integer)
var
InOutBoxJnlLineDim: Record "IC Inbox/Outbox Jnl. Line Dim.";
DimSetEntry: Record "Dimension Set Entry";
ICDim: Code[20];
ICDimValue: Code[20];
begin
DimSetEntry.SetRange("Dimension Set ID", DimSetID);
if DimSetEntry.FindSet() then
repeat
ICDim := ConvertDimtoICDim(DimSetEntry."Dimension Code");
ICDimValue := ConvertDimValuetoICDimVal(DimSetEntry."Dimension Code", DimSetEntry."Dimension Value Code");
if (ICDim <> '') and (ICDimValue <> '') then begin
InOutBoxJnlLineDim.Init();
InOutBoxJnlLineDim."Table ID" := TableID;
InOutBoxJnlLineDim."IC Partner Code" := PartnerCode;
InOutBoxJnlLineDim."Transaction No." := TransactionNo;
InOutBoxJnlLineDim."Transaction Source" := TransactionSource;
InOutBoxJnlLineDim."Line No." := LineNo;
InOutBoxJnlLineDim."Dimension Code" := ICDim;
InOutBoxJnlLineDim."Dimension Value Code" := ICDimValue;
InOutBoxJnlLineDim.Insert();
end;
until DimSetEntry.Next() = 0;
end;
/// <summary>
/// Handles default dimension setup when a new default dimension is inserted.
/// Updates related job task dimensions and cost types when applicable.
/// </summary>
/// <param name="DefaultDimension">Default dimension record being inserted</param>
procedure DefaultDimOnInsert(DefaultDimension: Record "Default Dimension")
var
CallingTrigger: Option OnInsert,OnModify,OnDelete;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeDefaultDimOnInsert(DefaultDimension, IsHandled);
if IsHandled then
exit;
if DefaultDimension."Table ID" = Database::Job then
UpdateJobTaskDim(DefaultDimension, false);
UpdateCostType(DefaultDimension, CallingTrigger::OnInsert);
end;
/// <summary>
/// Handles default dimension changes when an existing default dimension is modified.
/// Updates related job task dimensions and cost types to reflect the changes.
/// </summary>
/// <param name="DefaultDimension">Default dimension record being modified</param>
procedure DefaultDimOnModify(DefaultDimension: Record "Default Dimension")
var
CallingTrigger: Option OnInsert,OnModify,OnDelete;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeDefaultDimOnModify(DefaultDimension, IsHandled);
if IsHandled then
exit;
if DefaultDimension."Table ID" = Database::Job then
UpdateJobTaskDim(DefaultDimension, false);
UpdateCostType(DefaultDimension, CallingTrigger::OnModify);
end;
/// <summary>
/// Handles default dimension cleanup when a default dimension is deleted.
/// Removes related job task dimensions and updates cost types accordingly.
/// </summary>
/// <param name="DefaultDimension">Default dimension record being deleted</param>
procedure DefaultDimOnDelete(DefaultDimension: Record "Default Dimension")
var
CallingTrigger: Option OnInsert,OnModify,OnDelete;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeDefaultDimOnDelete(DefaultDimension, IsHandled);
if IsHandled then
exit;
if DefaultDimension."Table ID" = Database::Job then
UpdateJobTaskDim(DefaultDimension, true);
UpdateCostType(DefaultDimension, CallingTrigger::OnDelete);
end;
/// <summary>
/// Copies intercompany journal line dimensions from one record set to another.
/// Creates duplicate dimension entries for intercompany transaction processing.
/// </summary>
/// <param name="FromInOutBoxLineDim">Source intercompany journal line dimensions to copy from</param>
/// <param name="ToInOutBoxlineDim">Target intercompany journal line dimensions to copy to</param>
procedure CopyICJnlDimToICJnlDim(var FromInOutBoxLineDim: Record "IC Inbox/Outbox Jnl. Line Dim."; var ToInOutBoxlineDim: Record "IC Inbox/Outbox Jnl. Line Dim.")
begin
if FromInOutBoxLineDim.FindSet() then
repeat
ToInOutBoxlineDim := FromInOutBoxLineDim;
ToInOutBoxlineDim.Insert();
until FromInOutBoxLineDim.Next() = 0;
end;
/// <summary>
/// Copies dimension set entries from documents to intercompany document dimensions.
/// Converts company-specific dimension codes to intercompany dimension codes for cross-company transactions.
/// </summary>
/// <param name="TableID">Source table identifier for the document</param>
/// <param name="TransactionNo">Intercompany transaction number</param>
/// <param name="PartnerCode">Intercompany partner code</param>
/// <param name="TransactionSource">Source of the intercompany transaction</param>
/// <param name="LineNo">Line number within the document</param>
/// <param name="DimSetEntryID">Dimension set ID containing dimensions to copy</param>
procedure CopyDocDimtoICDocDim(TableID: Integer; TransactionNo: Integer; PartnerCode: Code[20]; TransactionSource: Option; LineNo: Integer; DimSetEntryID: Integer)
var
InOutBoxDocDim: Record "IC Document Dimension";
DimSetEntry: Record "Dimension Set Entry";
ICDim: Code[20];
ICDimValue: Code[20];
begin
DimSetEntry.SetRange("Dimension Set ID", DimSetEntryID);
if DimSetEntry.FindSet() then
repeat
ICDim := ConvertDimtoICDim(DimSetEntry."Dimension Code");
ICDimValue := ConvertDimValuetoICDimVal(DimSetEntry."Dimension Code", DimSetEntry."Dimension Value Code");
if (ICDim <> '') and (ICDimValue <> '') then begin
InOutBoxDocDim.Init();
InOutBoxDocDim."Table ID" := TableID;
InOutBoxDocDim."IC Partner Code" := PartnerCode;
InOutBoxDocDim."Transaction No." := TransactionNo;
InOutBoxDocDim."Transaction Source" := TransactionSource;
InOutBoxDocDim."Line No." := LineNo;
InOutBoxDocDim."Dimension Code" := ICDim;
InOutBoxDocDim."Dimension Value Code" := ICDimValue;
InOutBoxDocDim.Insert();
end;
until DimSetEntry.Next() = 0;
end;
/// <summary>
/// Copies intercompany document dimensions from one record set to another with new table and transaction source.
/// Creates duplicate dimension entries for intercompany document processing across different table contexts.
/// </summary>
/// <param name="FromSourceICDocDim">Source intercompany document dimensions to copy from</param>
/// <param name="ToSourceICDocDim">Target intercompany document dimensions to copy to</param>
/// <param name="ToTableID">Target table identifier for the copied dimensions</param>
/// <param name="ToTransactionSource">Target transaction source for the copied dimensions</param>
procedure CopyICDocDimtoICDocDim(FromSourceICDocDim: Record "IC Document Dimension"; var ToSourceICDocDim: Record "IC Document Dimension"; ToTableID: Integer; ToTransactionSource: Integer)
begin
SetICDocDimFilters(FromSourceICDocDim, FromSourceICDocDim."Table ID", FromSourceICDocDim."Transaction No.", FromSourceICDocDim."IC Partner Code", FromSourceICDocDim."Transaction Source", FromSourceICDocDim."Line No.");
if FromSourceICDocDim.FindSet() then
repeat
ToSourceICDocDim := FromSourceICDocDim;
ToSourceICDocDim."Table ID" := ToTableID;
ToSourceICDocDim."Transaction Source" := ToTransactionSource;
ToSourceICDocDim.Insert();
until FromSourceICDocDim.Next() = 0;
end;
/// <summary>
/// Moves intercompany document dimensions from one record set to another with new table and transaction source.
/// Transfers dimension entries and deletes the source records during intercompany document processing.
/// </summary>
/// <param name="FromSourceICDocDim">Source intercompany document dimensions to move from</param>
/// <param name="ToSourceICDocDim">Target intercompany document dimensions to move to</param>
/// <param name="ToTableID">Target table identifier for the moved dimensions</param>
/// <param name="ToTransactionSource">Target transaction source for the moved dimensions</param>
procedure MoveICDocDimtoICDocDim(FromSourceICDocDim: Record "IC Document Dimension"; var ToSourceICDocDim: Record "IC Document Dimension"; ToTableID: Integer; ToTransactionSource: Integer)
begin
SetICDocDimFilters(FromSourceICDocDim, FromSourceICDocDim."Table ID", FromSourceICDocDim."Transaction No.", FromSourceICDocDim."IC Partner Code", FromSourceICDocDim."Transaction Source", FromSourceICDocDim."Line No.");
if FromSourceICDocDim.FindSet() then
repeat
ToSourceICDocDim := FromSourceICDocDim;
ToSourceICDocDim."Table ID" := ToTableID;
ToSourceICDocDim."Transaction Source" := ToTransactionSource;
ToSourceICDocDim.Insert();
FromSourceICDocDim.Delete();
until FromSourceICDocDim.Next() = 0;
end;
/// <summary>
/// Sets filters on intercompany document dimension record to isolate specific dimension entries.
/// Applies standard filters for table ID, transaction number, partner code, transaction source, and line number.
/// </summary>
/// <param name="ICDocDim">Intercompany document dimension record to apply filters to</param>
/// <param name="TableID">Table identifier to filter by</param>
/// <param name="TransactionNo">Transaction number to filter by</param>
/// <param name="PartnerCode">Intercompany partner code to filter by</param>
/// <param name="TransactionSource">Transaction source to filter by</param>
/// <param name="LineNo">Line number to filter by</param>
procedure SetICDocDimFilters(var ICDocDim: Record "IC Document Dimension"; TableID: Integer; TransactionNo: Integer; PartnerCode: Code[20]; TransactionSource: Integer; LineNo: Integer)
begin
ICDocDim.Reset();
ICDocDim.SetRange("Table ID", TableID);
ICDocDim.SetRange("Transaction No.", TransactionNo);
ICDocDim.SetRange("IC Partner Code", PartnerCode);
ICDocDim.SetRange("Transaction Source", TransactionSource);
ICDocDim.SetRange("Line No.", LineNo);
end;
/// <summary>
/// Deletes intercompany document dimensions that match the specified criteria.
/// Removes all dimension entries for a specific intercompany document transaction line.
/// </summary>
/// <param name="TableID">Table identifier to delete dimensions for</param>
/// <param name="ICTransactionNo">Intercompany transaction number</param>
/// <param name="ICPartnerCode">Intercompany partner code</param>
/// <param name="TransactionSource">Transaction source type</param>
/// <param name="LineNo">Line number within the transaction</param>
procedure DeleteICDocDim(TableID: Integer; ICTransactionNo: Integer; ICPartnerCode: Code[20]; TransactionSource: Option; LineNo: Integer)
var
ICDocDim: Record "IC Document Dimension";
begin
SetICDocDimFilters(ICDocDim, TableID, ICTransactionNo, ICPartnerCode, TransactionSource, LineNo);
if not ICDocDim.IsEmpty() then
ICDocDim.DeleteAll();
end;
/// <summary>
/// Deletes intercompany journal line dimensions that match the specified criteria.
/// Removes all dimension entries for a specific intercompany journal line transaction.
/// </summary>
/// <param name="TableID">Table identifier to delete dimensions for</param>
/// <param name="ICTransactionNo">Intercompany transaction number</param>
/// <param name="ICPartnerCode">Intercompany partner code</param>
/// <param name="TransactionSource">Transaction source type</param>
/// <param name="LineNo">Line number within the transaction</param>
procedure DeleteICJnlDim(TableID: Integer; ICTransactionNo: Integer; ICPartnerCode: Code[20]; TransactionSource: Option; LineNo: Integer)
var
ICJnlDim: Record "IC Inbox/Outbox Jnl. Line Dim.";
begin
ICJnlDim.SetRange("Table ID", TableID);
ICJnlDim.SetRange("Transaction No.", ICTransactionNo);
ICJnlDim.SetRange("IC Partner Code", ICPartnerCode);
ICJnlDim.SetRange("Transaction Source", TransactionSource);
ICJnlDim.SetRange("Line No.", LineNo);
if not ICJnlDim.IsEmpty() then
ICJnlDim.DeleteAll();
end;
local procedure ConvertICDimtoDim(FromICDimCode: Code[20]) DimCode: Code[20]
var
ICDim: Record "IC Dimension";
begin
if ICDim.Get(FromICDimCode) then
DimCode := ICDim."Map-to Dimension Code";
OnAfterConvertICDimtoDim(FromICDimCode, DimCode);
end;
local procedure ConvertICDimValuetoDimValue(FromICDimCode: Code[20]; FromICDimValue: Code[20]) DimValueCode: Code[20]
var
ICDimValue: Record "IC Dimension Value";
begin
if ICDimValue.Get(FromICDimCode, FromICDimValue) then
DimValueCode := ICDimValue."Map-to Dimension Value Code";
OnAfterConvertICDimValuetoDimValue(FromICDimCode, FromICDimValue, DimValueCode);
end;
/// <summary>
/// Converts a company-specific dimension code to its intercompany equivalent.
/// Uses the dimension's mapping configuration to return the corresponding IC dimension code.
/// </summary>
/// <param name="FromDim">Company dimension code to convert</param>
/// <returns>Mapped intercompany dimension code, or empty if no mapping exists</returns>
procedure ConvertDimtoICDim(FromDim: Code[20]) ICDimCode: Code[20]
var
Dim: Record Dimension;
begin
if Dim.Get(FromDim) then
ICDimCode := Dim."Map-to IC Dimension Code";
OnAfterConvertDimtoICDim(FromDim, ICDimCode);
end;
/// <summary>
/// Converts a company-specific dimension value to its intercompany equivalent.
/// Uses the dimension value's mapping configuration to return the corresponding IC dimension value code.
/// </summary>
/// <param name="FromDim">Company dimension code containing the value</param>
/// <param name="FromDimValue">Company dimension value code to convert</param>
/// <returns>Mapped intercompany dimension value code, or empty if no mapping exists</returns>
procedure ConvertDimValuetoICDimVal(FromDim: Code[20]; FromDimValue: Code[20]) ICDimValueCode: Code[20]
var
DimValue: Record "Dimension Value";
begin
OnBeforeConvertDimValuetoICDimVal(DimValue);
if DimValue.Get(FromDim, FromDimValue) then
ICDimValueCode := DimValue."Map-to IC Dimension Value Code";
OnAfterConvertDimValuetoICDimVal(FromDim, FromDimValue, ICDimValueCode);
end;
/// <summary>
/// Validates intercompany dimension value and checks if it exists and is not blocked.
/// Performs validation and logging for intercompany dimension value usage.
/// </summary>
/// <param name="ICDimCode">Intercompany dimension code to validate</param>
/// <param name="ICDimValCode">Intercompany dimension value code to validate</param>
/// <returns>True if the intercompany dimension value is valid and not blocked, false otherwise</returns>
procedure CheckICDimValue(ICDimCode: Code[20]; ICDimValCode: Code[20]): Boolean
var
ICDimVal: Record "IC Dimension Value";
IsHandled: Boolean;
Result: Boolean;
begin
Result := false;
IsHandled := false;
OnBeforeCheckICDimValue(ICDimCode, ICDimValCode, Result, IsHandled);
if IsHandled then
exit(Result);
if (ICDimCode <> '') and (ICDimValCode <> '') then
if ICDimVal.Get(ICDimCode, ICDimValCode) then begin
if ICDimVal.Blocked then begin
LogError(
ICDimVal.RecordId, ICDimVal.FieldNo(Blocked),
StrSubstNo(DimValueBlockedErr, ICDimVal.TableCaption(), ICDimCode, ICDimValCode), '');
exit(false);
end;
if not CheckICDimValueAllowed(ICDimVal) then begin
LogError(
ICDimVal.RecordId, ICDimVal.FieldNo("Dimension Value Type"),
StrSubstNo(
DimValueMustNotBeErr, ICDimVal.TableCaption(), ICDimCode, ICDimValCode,
Format(ICDimVal."Dimension Value Type")),
'');
exit(false);
end;
end else begin
LogError(
Database::"IC Dimension Value", 0,
StrSubstNo(DimValueMissingErr, ICDimVal.TableCaption(), ICDimCode, ICDimValCode), '');
exit(false);
end;
exit(true);
end;
local procedure CheckICDimValueAllowed(ICDimVal: Record "IC Dimension Value"): Boolean
var
DimValueAllowed: Boolean;
begin
DimValueAllowed :=
ICDimVal."Dimension Value Type" in [ICDimVal."Dimension Value Type"::Standard, ICDimVal."Dimension Value Type"::"Begin-Total"];
OnCheckICDimValueAllowed(ICDimVal, DimValueAllowed);
exit(DimValueAllowed);
end;
/// <summary>
/// Validates intercompany dimension and checks if it exists and is not blocked.
/// Performs validation and logging for intercompany dimension usage.
/// </summary>
/// <param name="ICDimCode">Intercompany dimension code to validate</param>
/// <returns>True if the intercompany dimension is valid and not blocked, false otherwise</returns>
procedure CheckICDim(ICDimCode: Code[20]): Boolean
var
ICDim: Record "IC Dimension";
IsHandled: Boolean;
Result: Boolean;
begin
Result := false;
IsHandled := false;
OnBeforeCheckICDim(ICDimCode, Result, IsHandled);
if IsHandled then
exit(Result);
if ICDim.Get(ICDimCode) then begin
if ICDim.Blocked then begin
LogError(
ICDim.RecordId, ICDim.FieldNo(Blocked), StrSubstNo(Text014, ICDim.TableCaption(), ICDimCode), '');
exit(false);
end;
end else begin
LogError(
Database::"IC Dimension", 0, StrSubstNo(Text015, ICDim.TableCaption(), ICDimCode), '');
exit(false);
end;
exit(true);
end;
/// <summary>
/// Saves or updates a job task dimension value for a specific shortcut dimension field.
/// Creates new job task dimension records or modifies existing ones based on field number and dimension code.
/// </summary>
/// <param name="JobNo">Job number to save dimension for</param>
/// <param name="JobTaskNo">Job task number to save dimension for</param>
/// <param name="FieldNumber">Shortcut dimension field number (1-8)</param>
/// <param name="ShortcutDimCode">Dimension value code to assign to the shortcut field</param>
procedure SaveJobTaskDim(JobNo: Code[20]; JobTaskNo: Code[20]; FieldNumber: Integer; ShortcutDimCode: Code[20])
var
JobTaskDim: Record "Job Task Dimension";
begin
GetGLSetup(GLSetupShortcutDimCode);
if ShortcutDimCode <> '' then begin
if JobTaskDim.Get(JobNo, JobTaskNo, GLSetupShortcutDimCode[FieldNumber])
then begin
JobTaskDim.Validate("Dimension Value Code", ShortcutDimCode);
JobTaskDim.Modify();
end else begin
JobTaskDim.Init();
JobTaskDim.Validate("Job No.", JobNo);
JobTaskDim.Validate("Job Task No.", JobTaskNo);
JobTaskDim.Validate("Dimension Code", GLSetupShortcutDimCode[FieldNumber]);
JobTaskDim.Validate("Dimension Value Code", ShortcutDimCode);
JobTaskDim.Insert();
end;
end else
if JobTaskDim.Get(JobNo, JobTaskNo, GLSetupShortcutDimCode[FieldNumber]) then
JobTaskDim.Delete();
end;
/// <summary>
/// Saves job task dimension value to temporary buffer for a specific shortcut dimension field.
/// Updates temporary dimension buffer with shortcut dimension values for later processing.
/// </summary>
/// <param name="FieldNumber">Shortcut dimension field number (1-8)</param>
/// <param name="ShortcutDimCode">Dimension value code to save to the temporary buffer</param>
procedure SaveJobTaskTempDim(FieldNumber: Integer; ShortcutDimCode: Code[20])
begin
GetGLSetup(GLSetupShortcutDimCode);
if ShortcutDimCode <> '' then begin
if TempJobTaskDimBuffer.Get('', '', GLSetupShortcutDimCode[FieldNumber])
then begin
TempJobTaskDimBuffer."Dimension Value Code" := ShortcutDimCode;
TempJobTaskDimBuffer.Modify();
end else begin
TempJobTaskDimBuffer.Init();
TempJobTaskDimBuffer."Dimension Code" := GLSetupShortcutDimCode[FieldNumber];
TempJobTaskDimBuffer."Dimension Value Code" := ShortcutDimCode;
TempJobTaskDimBuffer.Insert();
end;
end else
if TempJobTaskDimBuffer.Get('', '', GLSetupShortcutDimCode[FieldNumber]) then
TempJobTaskDimBuffer.Delete();
end;
/// <summary>
/// Inserts job task dimensions based on default dimensions from the job.
/// Creates job task dimension records and updates global dimension variables with values found.
/// </summary>
/// <param name="JobNo">Job number to create task dimensions for</param>
/// <param name="JobTaskNo">Job task number to create dimensions for</param>
/// <param name="GlobalDim1Code">Returns global dimension 1 code if found in job task dimensions</param>
/// <param name="GlobalDim2Code">Returns global dimension 2 code if found in job task dimensions</param>
procedure InsertJobTaskDim(JobNo: Code[20]; JobTaskNo: Code[20]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20])
var
DefaultDim: Record "Default Dimension";
JobTaskDim: Record "Job Task Dimension";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeInsertJobTaskDim(JobNo, JobTaskNo, GlobalDim1Code, GlobalDim2Code, IsHandled);
if IsHandled then
exit;
GetGLSetup(GLSetupShortcutDimCode);
DefaultDim.SetRange("Table ID", Database::Job);
DefaultDim.SetRange("No.", JobNo);
if DefaultDim.FindSet(false) then
repeat
if DefaultDim."Dimension Value Code" <> '' then begin
JobTaskDim.Init();
JobTaskDim."Job No." := JobNo;
JobTaskDim."Job Task No." := JobTaskNo;
JobTaskDim."Dimension Code" := DefaultDim."Dimension Code";
JobTaskDim."Dimension Value Code" := DefaultDim."Dimension Value Code";
JobTaskDim.Insert();
if JobTaskDim."Dimension Code" = GLSetupShortcutDimCode[1] then
GlobalDim1Code := JobTaskDim."Dimension Value Code";
if JobTaskDim."Dimension Code" = GLSetupShortcutDimCode[2] then
GlobalDim2Code := JobTaskDim."Dimension Value Code";
end;
until DefaultDim.Next() = 0;
TempJobTaskDimBuffer.Reset();
if TempJobTaskDimBuffer.FindSet() then
repeat
if not JobTaskDim.Get(JobNo, JobTaskNo, TempJobTaskDimBuffer."Dimension Code") then begin
JobTaskDim.Init();
JobTaskDim."Job No." := JobNo;
JobTaskDim."Job Task No." := JobTaskNo;
JobTaskDim."Dimension Code" := TempJobTaskDimBuffer."Dimension Code";
JobTaskDim."Dimension Value Code" := TempJobTaskDimBuffer."Dimension Value Code";
JobTaskDim.Insert();
if JobTaskDim."Dimension Code" = GLSetupShortcutDimCode[1] then
GlobalDim1Code := JobTaskDim."Dimension Value Code";
if JobTaskDim."Dimension Code" = GLSetupShortcutDimCode[2] then
GlobalDim2Code := JobTaskDim."Dimension Value Code";
end;
until TempJobTaskDimBuffer.Next() = 0;
TempJobTaskDimBuffer.DeleteAll();
end;
/// <summary>
/// Inserts job task dimensions based on default dimension configuration.
/// Creates job task dimension entries and updates global dimension codes for the job task.
/// </summary>
/// <param name="DefaultDim">Default dimension record to use as template</param>
/// <param name="JobNo">Job number for the job task dimensions</param>
/// <param name="JobTaskNo">Job task number for the dimension assignment</param>
/// <param name="GlobalDim1Code">Returns the global dimension 1 code assigned</param>
/// <param name="GlobalDim2Code">Returns the global dimension 2 code assigned</param>
procedure InsertJobTaskDim(var DefaultDim: Record "Default Dimension"; JobNo: Code[20]; JobTaskNo: Code[20]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20])
var
JobTaskDim: Record "Job Task Dimension";
begin
GetGLSetup(GLSetupShortcutDimCode);
DefaultDim.Reset();
DefaultDim.SetRange("Table ID", Database::"Job Task");
DefaultDim.SetRange("No.", JobTaskNo);
DefaultDim.SetFilter("Dimension Value Code", '<>%1', '');
if DefaultDim.FindSet(false) then
repeat
JobTaskDim.Init();
JobTaskDim."Job No." := JobNo;
JobTaskDim."Job Task No." := JobTaskNo;
JobTaskDim."Dimension Code" := DefaultDim."Dimension Code";
JobTaskDim."Dimension Value Code" := DefaultDim."Dimension Value Code";
JobTaskDim.Insert();
if JobTaskDim."Dimension Code" = GLSetupShortcutDimCode[1] then
GlobalDim1Code := JobTaskDim."Dimension Value Code";
if JobTaskDim."Dimension Code" = GLSetupShortcutDimCode[2] then
GlobalDim2Code := JobTaskDim."Dimension Value Code";
until DefaultDim.Next() = 0;
end;
local procedure UpdateJobTaskDim(DefaultDimension: Record "Default Dimension"; FromOnDelete: Boolean)
var
JobTaskDimension: Record "Job Task Dimension";
JobTask: Record "Job Task";
ConfirmManagement: Codeunit "Confirm Management";
IsHandled: Boolean;
begin
if DefaultDimension."Table ID" <> Database::Job then
exit;
JobTask.SetRange("Job No.", DefaultDimension."No.");
if JobTask.IsEmpty() then
exit;
if GetSkipUpdateDimensions() then
exit;
IsHandled := false;
OnUpdateJobTaskDimOnBeforConfirm(DefaultDimension, IsHandled);
if not IsHandled then
if not SkipChangeDimensionsQst then
if not ConfirmManagement.GetResponseOrDefault(Text019, true) then begin
SetSkipUpdateDimensions(true);
exit;
end;
JobTaskDimension.SetRange("Job No.", DefaultDimension."No.");
JobTaskDimension.SetRange("Dimension Code", DefaultDimension."Dimension Code");
JobTaskDimension.DeleteAll(true);
if FromOnDelete or
(DefaultDimension."Value Posting" = DefaultDimension."Value Posting"::"No Code") or
(DefaultDimension."Dimension Value Code" = '')
then
exit;
if JobTask.FindSet() then
repeat
Clear(JobTaskDimension);
JobTaskDimension."Job No." := JobTask."Job No.";
JobTaskDimension."Job Task No." := JobTask."Job Task No.";
JobTaskDimension."Dimension Code" := DefaultDimension."Dimension Code";
JobTaskDimension."Dimension Value Code" := DefaultDimension."Dimension Value Code";
JobTaskDimension.Insert(true);
until JobTask.Next() = 0;
OnAfterUpdateJobTaskDim(DefaultDimension);
end;
/// <summary>
/// Deletes all job task dimension records from temporary buffer.
/// </summary>
procedure DeleteJobTaskTempDim()
begin
TempJobTaskDimBuffer.Reset();
TempJobTaskDimBuffer.DeleteAll();
end;
/// <summary>
/// Copies job task dimensions from one job task to another job task.
/// </summary>
/// <param name="JobNo">Source job number</param>
/// <param name="JobTaskNo">Source job task number</param>
/// <param name="NewJobNo">Target job number</param>
/// <param name="NewJobTaskNo">Target job task number</param>
procedure CopyJobTaskDimToJobTaskDim(JobNo: Code[20]; JobTaskNo: Code[20]; NewJobNo: Code[20]; NewJobTaskNo: Code[20])
var
JobTaskDimension: Record "Job Task Dimension";
JobTaskDimension2: Record "Job Task Dimension";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopyJobTaskDimToJobTaskDim(JobNo, JobTaskNo, NewJobNo, NewJobTaskNo, IsHandled);
if IsHandled then
exit;
JobTaskDimension.Reset();
JobTaskDimension.SetRange("Job No.", JobNo);
JobTaskDimension.SetRange("Job Task No.", JobTaskNo);
if JobTaskDimension.FindSet() then
repeat
if not JobTaskDimension2.Get(NewJobNo, NewJobTaskNo, JobTaskDimension."Dimension Code") then begin
JobTaskDimension2.Init();
JobTaskDimension2."Job No." := NewJobNo;
JobTaskDimension2."Job Task No." := NewJobTaskNo;
JobTaskDimension2."Dimension Code" := JobTaskDimension."Dimension Code";
JobTaskDimension2."Dimension Value Code" := JobTaskDimension."Dimension Value Code";
JobTaskDimension2.Insert(true);
end else begin
JobTaskDimension2."Dimension Value Code" := JobTaskDimension."Dimension Value Code";
JobTaskDimension2.Modify(true);
end;
until JobTaskDimension.Next() = 0;
JobTaskDimension2.Reset();
JobTaskDimension2.SetRange("Job No.", NewJobNo);
JobTaskDimension2.SetRange("Job Task No.", NewJobTaskNo);
if JobTaskDimension2.FindSet() then
repeat
if not JobTaskDimension.Get(JobNo, JobTaskNo, JobTaskDimension2."Dimension Code") then
JobTaskDimension2.Delete(true);
until JobTaskDimension2.Next() = 0;
end;
/// <summary>
/// Checks consistency between document dimension set entries and posted document dimension set entries.
/// Validates that dimension sets match between original document and posted document for audit compliance.
/// </summary>
/// <param name="DimSetEntry">Dimension set entries from the original document</param>
/// <param name="PostedDimSetEntry">Dimension set entries from the posted document</param>
/// <param name="DocTableID">Table ID of the original document</param>
/// <param name="PostedDocTableID">Table ID of the posted document</param>
/// <returns>True if dimension sets are consistent, false if discrepancies are found</returns>
procedure CheckDimIDConsistency(var DimSetEntry: Record "Dimension Set Entry"; var PostedDimSetEntry: Record "Dimension Set Entry"; DocTableID: Integer; PostedDocTableID: Integer): Boolean
var
ObjectTranslation: Record "Object Translation";
begin
if DimSetEntry.FindSet() then;
if PostedDimSetEntry.FindSet() then;
repeat
case true of
DimSetEntry."Dimension Code" > PostedDimSetEntry."Dimension Code":
begin
LogError(
DimSetEntry.RecordId, 0,
StrSubstNo(
Text012,
DimSetEntry.FieldCaption("Dimension Code"),
ObjectTranslation.TranslateTable(DocTableID),
ObjectTranslation.TranslateTable(PostedDocTableID)),
'');
exit(false);
end;
DimSetEntry."Dimension Code" < PostedDimSetEntry."Dimension Code":
begin
LogError(
DimSetEntry.RecordId, 0,
StrSubstNo(
Text012,
PostedDimSetEntry.FieldCaption("Dimension Code"),
ObjectTranslation.TranslateTable(PostedDocTableID),
ObjectTranslation.TranslateTable(DocTableID))
, '');
exit(false);
end;
DimSetEntry."Dimension Code" = PostedDimSetEntry."Dimension Code":
if DimSetEntry."Dimension Value Code" <> PostedDimSetEntry."Dimension Value Code" then begin
LogError(
DimSetEntry.RecordId, 0,
StrSubstNo(
Text013,
DimSetEntry.FieldCaption("Dimension Value Code"),
DimSetEntry.FieldCaption("Dimension Code"),
DimSetEntry."Dimension Code",
ObjectTranslation.TranslateTable(DocTableID),
ObjectTranslation.TranslateTable(PostedDocTableID)),
'');
exit(false);
end;
end;
until (DimSetEntry.Next() = 0) and (PostedDimSetEntry.Next() = 0);
exit(true);
end;
local procedure CreateDimSetEntryFromDimValue(DimValue: Record "Dimension Value"; var TempDimSetEntry: Record "Dimension Set Entry" temporary)
begin
TempDimSetEntry."Dimension Code" := DimValue."Dimension Code";
TempDimSetEntry."Dimension Value Code" := DimValue.Code;
TempDimSetEntry."Dimension Value ID" := DimValue."Dimension Value ID";
TempDimSetEntry.Insert();
end;
/// <summary>
/// Creates a dimension set ID from intercompany document dimensions by converting IC dimensions to company dimensions.
/// Processes all IC document dimension entries and builds a corresponding company dimension set.
/// </summary>
/// <param name="ICDocDim">Intercompany document dimensions to convert</param>
/// <returns>Dimension set ID representing the converted intercompany dimensions</returns>
procedure CreateDimSetIDFromICDocDim(var ICDocDim: Record "IC Document Dimension"): Integer
var
DimValue: Record "Dimension Value";
TempDimSetEntry: Record "Dimension Set Entry" temporary;
begin
OnBeforeCreateDimSetIDFromICDocDim(DimValue);
if ICDocDim.Find('-') then
repeat
DimValue.Get(
ConvertICDimtoDim(ICDocDim."Dimension Code"),
ConvertICDimValuetoDimValue(ICDocDim."Dimension Code", ICDocDim."Dimension Value Code"));
CreateDimSetEntryFromDimValue(DimValue, TempDimSetEntry);
until ICDocDim.Next() = 0;
exit(GetDimensionSetID(TempDimSetEntry));
end;
/// <summary>
/// Creates a dimension set ID from intercompany journal line dimensions by converting IC dimensions to company dimensions.
/// Processes all IC journal line dimension entries and builds a corresponding company dimension set.
/// </summary>
/// <param name="ICInboxOutboxJnlLineDim">Intercompany journal line dimensions to convert</param>
/// <returns>Dimension set ID representing the converted intercompany journal dimensions</returns>
procedure CreateDimSetIDFromICJnlLineDim(var ICInboxOutboxJnlLineDim: Record "IC Inbox/Outbox Jnl. Line Dim."): Integer
var
DimValue: Record "Dimension Value";
TempDimSetEntry: Record "Dimension Set Entry" temporary;
begin
OnBeforeCreateDimSetIDFromICJnlLineDim(DimValue);
if ICInboxOutboxJnlLineDim.Find('-') then
repeat
DimValue.Get(
ConvertICDimtoDim(ICInboxOutboxJnlLineDim."Dimension Code"),
ConvertICDimValuetoDimValue(
ICInboxOutboxJnlLineDim."Dimension Code", ICInboxOutboxJnlLineDim."Dimension Value Code"));
CreateDimSetEntryFromDimValue(DimValue, TempDimSetEntry);
until ICInboxOutboxJnlLineDim.Next() = 0;
exit(GetDimensionSetID(TempDimSetEntry));
end;
/// <summary>
/// Copies dimension buffer entries to dimension set entry records with proper dimension value ID assignment.
/// Validates dimension values during the copy process and populates dimension value IDs from master data.
/// </summary>
/// <param name="FromDimBuf">Source dimension buffer records to copy from</param>
/// <param name="DimSetEntry">Target dimension set entry records to copy to</param>
procedure CopyDimBufToDimSetEntry(var FromDimBuf: Record "Dimension Buffer"; var DimSetEntry: Record "Dimension Set Entry")
var
DimValue: Record "Dimension Value";
begin
OnBeforeCopyDimBufToDimSetEntry(DimValue);
if FromDimBuf.FindSet() then
repeat
DimValue.Get(FromDimBuf."Dimension Code", FromDimBuf."Dimension Value Code");
DimSetEntry."Dimension Code" := FromDimBuf."Dimension Code";
DimSetEntry."Dimension Value Code" := FromDimBuf."Dimension Value Code";
DimSetEntry."Dimension Value ID" := DimValue."Dimension Value ID";
DimSetEntry.Insert();
until FromDimBuf.Next() = 0;
end;
/// <summary>
/// Creates a dimension set ID from dimension buffer entries by building a temporary dimension set.
/// Validates dimension values and generates a unique dimension set ID for the buffer contents.
/// </summary>
/// <param name="DimBuf">Dimension buffer records to create dimension set ID from</param>
/// <returns>Generated dimension set ID representing the buffer dimension combination</returns>
procedure CreateDimSetIDFromDimBuf(var DimBuf: Record "Dimension Buffer"): Integer
var
DimValue: Record "Dimension Value";
TempDimSetEntry: Record "Dimension Set Entry" temporary;
begin
OnBeforeCreateDimSetIDFromDimBuf(DimValue);
if DimBuf.FindSet() then
repeat
DimValue.Get(DimBuf."Dimension Code", DimBuf."Dimension Value Code");
CreateDimSetEntryFromDimValue(DimValue, TempDimSetEntry);
until DimBuf.Next() = 0;
exit(GetDimensionSetID(TempDimSetEntry));
end;
/// <summary>
/// Creates dimensions for purchase lines using higher priority dimension sources.
/// Applies dimension priority rules to resolve conflicts between different dimension sources.
/// </summary>
/// <param name="PurchaseLine">Purchase line record containing the dimension data</param>
/// <param name="CurrFieldNo">Current field number triggering the dimension creation</param>
/// <param name="DimensionSetID">Returns the created dimension set ID</param>
/// <param name="DimValue1">Returns the global dimension 1 value code</param>
/// <param name="DimValue2">Returns the global dimension 2 value code</param>
/// <param name="SourceCode">Source code for the transaction</param>
/// <param name="PriorityTableID">Table ID used for priority determination</param>
procedure CreateDimForPurchLineWithHigherPriorities(PurchaseLine: Record "Purchase Line"; CurrFieldNo: Integer; var DimensionSetID: Integer; var DimValue1: Code[20]; var DimValue2: Code[20]; SourceCode: Code[10]; PriorityTableID: Integer)
var
DefaultDimSource: List of [Dictionary of [Integer, Code[20]]];
HighPriorityDefaultDimSource: List of [Dictionary of [Integer, Code[20]]];
begin
AddDimSource(DefaultDimSource, Database::Job, PurchaseLine."Job No.");
AddDimSource(DefaultDimSource, PurchLineTypeToTableID(PurchaseLine.Type), PurchaseLine."No.");
OnBeforeGetTableIDsForHigherPrioritiesProcedure(Database::"Purchase Line", PurchaseLine, CurrFieldNo, DefaultDimSource);
if GetTableIDsForHigherPriorities(
DefaultDimSource, HighPriorityDefaultDimSource, SourceCode, PriorityTableID)
then
DimensionSetID :=
GetRecDefaultDimID(
PurchaseLine, CurrFieldNo, HighPriorityDefaultDimSource, SourceCode, DimValue1, DimValue2, 0, 0);
end;
/// <summary>
/// Creates dimensions for sales lines using higher priority dimension sources.
/// Applies dimension priority rules to resolve conflicts between different dimension sources.
/// </summary>
/// <param name="SalesLine">Sales line record containing the dimension data</param>
/// <param name="CurrFieldNo">Current field number triggering the dimension creation</param>
/// <param name="DimensionSetID">Returns the created dimension set ID</param>
/// <param name="DimValue1">Returns the global dimension 1 value code</param>
/// <param name="DimValue2">Returns the global dimension 2 value code</param>
/// <param name="SourceCode">Source code for the transaction</param>
/// <param name="PriorityTableID">Table ID used for priority determination</param>
procedure CreateDimForSalesLineWithHigherPriorities(SalesLine: Record "Sales Line"; CurrFieldNo: Integer; var DimensionSetID: Integer; var DimValue1: Code[20]; var DimValue2: Code[20]; SourceCode: Code[10]; PriorityTableID: Integer)
var
DefaultDimSource: List of [Dictionary of [Integer, Code[20]]];
HighPriorityDefaultDimSource: List of [Dictionary of [Integer, Code[20]]];
begin
AddDimSource(DefaultDimSource, Database::Job, SalesLine."Job No.");
AddDimSource(DefaultDimSource, SalesLineTypeToTableID(SalesLine.Type), SalesLine."No.");
OnBeforeGetTableIDsForHigherPrioritiesProcedure(Database::"Sales Line", SalesLine, CurrFieldNo, DefaultDimSource);
if GetTableIDsForHigherPriorities(
DefaultDimSource, HighPriorityDefaultDimSource, SourceCode, PriorityTableID)
then
DimensionSetID :=
GetRecDefaultDimID(
SalesLine, CurrFieldNo, HighPriorityDefaultDimSource, SourceCode, DimValue1, DimValue2, 0, 0);
end;
/// <summary>
/// Creates dimensions for job journal lines using higher priority dimension sources.
/// Applies dimension priority rules to resolve conflicts between different dimension sources.
/// </summary>
/// <param name="JobJournalLine">Job journal line record containing the dimension data</param>
/// <param name="CurrFieldNo">Current field number triggering the dimension creation</param>
/// <param name="DimensionSetID">Returns the created dimension set ID</param>
/// <param name="DimValue1">Returns the global dimension 1 value code</param>
/// <param name="DimValue2">Returns the global dimension 2 value code</param>
/// <param name="SourceCode">Source code for the transaction</param>
/// <param name="PriorityTableID">Table ID used for priority determination</param>
procedure CreateDimForJobJournalLineWithHigherPriorities(JobJournalLine: Record "Job Journal Line"; CurrFieldNo: Integer; var DimensionSetID: Integer; var DimValue1: Code[20]; var DimValue2: Code[20]; SourceCode: Code[10]; PriorityTableID: Integer)
var
DefaultDimSource: List of [Dictionary of [Integer, Code[20]]];
HighPriorityDefaultDimSource: List of [Dictionary of [Integer, Code[20]]];
begin
AddDimSource(DefaultDimSource, Database::Job, JobJournalLine."Job No.");
AddDimSource(DefaultDimSource, Database::Location, JobJournalLine."Location Code");
AddDimSource(DefaultDimSource, TypeToTableID2(JobJournalLine.Type.AsInteger()), JobJournalLine."No.");
AddDimSource(DefaultDimSource, Database::"Resource Group", JobJournalLine."Resource Group No.");
OnBeforeGetTableIDsForHigherPrioritiesProcedure(Database::"Job Journal Line", JobJournalLine, CurrFieldNo, DefaultDimSource);
if GetTableIDsForHigherPriorities(
DefaultDimSource, HighPriorityDefaultDimSource, SourceCode, PriorityTableID)
then
DimensionSetID :=
GetRecDefaultDimID(
JobJournalLine, CurrFieldNo, HighPriorityDefaultDimSource, SourceCode, DimValue1, DimValue2, 0, 0);
OnAfterCreateDimForJobJournalLineWithHigherPrioritiesProcedure(JobJournalLine, CurrFieldNo, DimensionSetID, DimValue1, DimValue2, SourceCode, PriorityTableID, DefaultDimSource, HighPriorityDefaultDimSource);
end;
/// <summary>
/// Retrieves table IDs for higher priority dimension sources based on default dimension priority configuration.
/// Filters dimension sources to include only those with higher priority than the specified priority table.
/// </summary>
/// <param name="DefaultDimSource">List of default dimension sources to filter</param>
/// <param name="HighPriorityDefaultDimSource">Returns filtered list containing only higher priority sources</param>
/// <param name="SourceCode">Source code for priority lookup</param>
/// <param name="PriorityTableID">Table ID used as priority threshold for filtering</param>
/// <returns>True if higher priority sources exist, false otherwise</returns>
procedure GetTableIDsForHigherPriorities(DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; var HighPriorityDefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; SourceCode: Code[10]; PriorityTableID: Integer) Result: Boolean
var
DefaultDimensionPriority: Record "Default Dimension Priority";
InitialPriority: Integer;
i: Integer;
j: Integer;
TableID: Integer;
DimSource: Dictionary of [Integer, Code[20]];
begin
Clear(HighPriorityDefaultDimSource);
if DefaultDimensionPriority.Get(SourceCode, PriorityTableID) then
InitialPriority := DefaultDimensionPriority.Priority;
DefaultDimensionPriority.SetRange("Source Code", SourceCode);
DefaultDimensionPriority.SetFilter(Priority, '<=%1', InitialPriority);
i := 1;
for j := 1 to DefaultDimSource.Count do begin
DimSource := DefaultDimSource.Get(j);
TableID := DimSource.Keys.Get(1);
if TableID = 0 then
break;
DefaultDimensionPriority.Priority := 0;
DefaultDimensionPriority.SetRange("Table ID", TableID);
if ((InitialPriority = 0) or DefaultDimensionPriority.FindFirst()) and
((DefaultDimensionPriority.Priority < InitialPriority) or
((DefaultDimensionPriority.Priority = InitialPriority) and (TableID < PriorityTableID)))
then begin
Result := true;
AddDimSource(HighPriorityDefaultDimSource, TableID, DimSource.Values.Get(1));
i += 1;
end;
end;
exit(Result);
end;
/// <summary>
/// Builds a collection of dimension set IDs that match the specified dimension code and value filter.
/// Populates temporary dimension set entry buffer with matching dimension set IDs for subsequent filtering operations.
/// </summary>
/// <param name="DimCode">Dimension code to filter by</param>
/// <param name="DimValueFilter">Dimension value filter expression to apply</param>
procedure GetDimSetIDsForFilter(DimCode: Code[20]; DimValueFilter: Text)
var
DimSetEntry: Record "Dimension Set Entry";
begin
DimSetEntry.SetCurrentKey("Dimension Code", "Dimension Value Code", "Dimension Set ID");
DimSetEntry.SetFilter("Dimension Code", '%1', DimCode);
DimSetEntry.SetFilter("Dimension Value Code", DimValueFilter);
if DimSetEntry.FindSet() then
repeat
AddDimSetIDtoTempEntry(TempDimSetEntryBuffer, DimSetEntry."Dimension Set ID");
until DimSetEntry.Next() = 0;
if FilterIncludesBlank(DimCode, DimValueFilter) then
GetDimSetIDsForBlank(DimCode);
DimSetFilterCtr += 1;
end;
local procedure GetDimSetIDsForBlank(DimCode: Code[20])
var
TempDimSetEntry: Record "Dimension Set Entry" temporary;
DimSetEntry: Record "Dimension Set Entry";
PrevDimSetID: Integer;
i: Integer;
begin
AddDimSetIDtoTempEntry(TempDimSetEntry, 0);
for i := 1 to 2 do begin
if i = 2 then
DimSetEntry.SetFilter("Dimension Code", '%1', DimCode);
if DimSetEntry.FindSet() then begin
PrevDimSetID := 0;
repeat
if DimSetEntry."Dimension Set ID" <> PrevDimSetID then begin
AddDimSetIDtoTempEntry(TempDimSetEntry, DimSetEntry."Dimension Set ID");
PrevDimSetID := DimSetEntry."Dimension Set ID";
end;
until DimSetEntry.Next() = 0;
end;
end;
TempDimSetEntry.SetFilter("Dimension Value ID", '%1', 1);
if TempDimSetEntry.FindSet() then
repeat
AddDimSetIDtoTempEntry(TempDimSetEntryBuffer, TempDimSetEntry."Dimension Set ID");
until TempDimSetEntry.Next() = 0;
end;
procedure ChunkDimSetFilters(var TempDimensionSetEntry: Record "Dimension Set Entry" temporary): List of [Text]
var
DimSetFilters: List of [Text];
CurrentDimSetFilter: Text;
Parameters, MaxParameters : Integer;
MaxStrLen: Integer;
begin
MaxParameters := 1000;
MaxStrLen := 4000;
if not TempDimensionSetEntry.FindSet() then
exit(DimSetFilters);
CurrentDimSetFilter := '';
repeat
if CurrentDimSetFilter <> '' then
CurrentDimSetFilter += '|';
CurrentDimSetFilter += Format(TempDimensionSetEntry."Dimension Set ID");
Parameters += 1;
if (Parameters > MaxParameters) or (StrLen(CurrentDimSetFilter) > MaxStrLen) then begin
DimSetFilters.Add(CurrentDimSetFilter);
CurrentDimSetFilter := '';
Parameters := 0;
end;
until TempDimensionSetEntry.Next() = 0;
if CurrentDimSetFilter <> '' then
DimSetFilters.Add(CurrentDimSetFilter);
exit(DimSetFilters);
end;
/// <summary>
/// Gets dimension set filters as list of text for current dimension set filter counter.
/// </summary>
/// <returns>List of text containing dimension set filters for the current counter value</returns>
procedure GetDimSetFilters(): List of [Text]
begin
TempDimSetEntryBuffer.SetFilter("Dimension Value ID", '%1', DimSetFilterCtr);
exit(ChunkDimSetFilters(TempDimSetEntryBuffer));
end;
/// <summary>
/// Gets single dimension set filter string based on current dimension set filter counter.
/// </summary>
/// <returns>Dimension set filter as concatenated text string</returns>
procedure GetDimSetFilter() DimSetFilter: Text
var
Counter: integer;
MaxParameters: Integer;
StringLimitation: Integer;
begin
Counter := 0;
MaxParameters := 1000;
StringLimitation := 4000;
TempDimSetEntryBuffer.SetFilter("Dimension Value ID", '%1', DimSetFilterCtr);
if TempDimSetEntryBuffer.FindSet() then begin
DimSetFilter := Format(TempDimSetEntryBuffer."Dimension Set ID");
if TempDimSetEntryBuffer.Next() <> 0 then
repeat
Counter := Counter + 1;
DimSetFilter += '|' + Format(TempDimSetEntryBuffer."Dimension Set ID");
until TempDimSetEntryBuffer.Next() = 0;
if (Counter > MaxParameters) or (StrLen(DimSetFilter) > StringLimitation) then
Error(ToManyParametersErr);
end;
end;
local procedure FilterIncludesBlank(DimCode: Code[20]; DimValueFilter: Text): Boolean
var
TempDimSetEntry: Record "Dimension Set Entry" temporary;
begin
TempDimSetEntry."Dimension Code" := DimCode;
TempDimSetEntry.Insert();
TempDimSetEntry.SetFilter("Dimension Value Code", DimValueFilter);
exit(not TempDimSetEntry.IsEmpty);
end;
local procedure AddDimSetIDtoTempEntry(var TempDimSetEntry: Record "Dimension Set Entry" temporary; DimSetID: Integer)
begin
if TempDimSetEntry.Get(DimSetID, '') then begin
TempDimSetEntry."Dimension Value ID" += 1;
TempDimSetEntry.Modify();
end else begin
TempDimSetEntry."Dimension Set ID" := DimSetID;
TempDimSetEntry."Dimension Value ID" := 1;
TempDimSetEntry.Insert();
end;
end;
/// <summary>
/// Clears dimension set filter by resetting buffer and counter.
/// </summary>
procedure ClearDimSetFilter()
begin
TempDimSetEntryBuffer.Reset();
TempDimSetEntryBuffer.DeleteAll();
DimSetFilterCtr := 0;
end;
/// <summary>
/// Gets temporary dimension set entry from buffer.
/// </summary>
/// <param name="TempDimSetEntry">Temporary dimension set entry to copy buffer data to</param>
procedure GetTempDimSetEntry(var TempDimSetEntry: Record "Dimension Set Entry" temporary)
begin
TempDimSetEntry.Copy(TempDimSetEntryBuffer, true);
end;
/// <summary>
/// Updates cost accounting types when default dimensions are modified for G/L accounts.
/// Integrates dimension changes with cost accounting setup to maintain consistency between financial and cost dimensions.
/// </summary>
/// <param name="DefaultDimension">Default dimension record being modified</param>
/// <param name="CallingTrigger">Trigger context indicating the type of operation (Insert, Modify, Delete)</param>
procedure UpdateCostType(DefaultDimension: Record "Default Dimension"; CallingTrigger: Option OnInsert,OnModify,OnDelete)
var
GLAccount: Record "G/L Account";
CostAccSetup: Record "Cost Accounting Setup";
CostAccMgt: Codeunit "Cost Account Mgt";
begin
if CostAccSetup.Get() and (DefaultDimension."Table ID" = Database::"G/L Account") then
if GLAccount.Get(DefaultDimension."No.") then
CostAccMgt.UpdateCostTypeFromDefaultDimension(DefaultDimension, GLAccount, CallingTrigger);
end;
/// <summary>
/// Creates dimension set ID from job task dimensions and updates global dimension values.
/// </summary>
/// <param name="JobNo">Job number to get dimensions from</param>
/// <param name="JobTaskNo">Job task number to get dimensions from</param>
/// <param name="GlobalDimVal1">Returns global dimension 1 value</param>
/// <param name="GlobalDimVal2">Returns global dimension 2 value</param>
/// <returns>New dimension set ID created from job task dimensions</returns>
procedure CreateDimSetFromJobTaskDim(JobNo: Code[20]; JobTaskNo: Code[20]; var GlobalDimVal1: Code[20]; var GlobalDimVal2: Code[20]) NewDimSetID: Integer
var
JobTaskDimension: Record "Job Task Dimension";
DimValue: Record "Dimension Value";
TempDimSetEntry: Record "Dimension Set Entry" temporary;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCreateDimSetFromJobTaskDim(JobNo, JobTaskNo, GlobalDimVal1, GlobalDimVal2, NewDimSetID, IsHandled, DimValue);
if IsHandled then
exit(NewDimSetID);
JobTaskDimension.SetRange("Job No.", JobNo);
JobTaskDimension.SetRange("Job Task No.", JobTaskNo);
if JobTaskDimension.FindSet() then begin
repeat
DimValue.Get(JobTaskDimension."Dimension Code", JobTaskDimension."Dimension Value Code");
TempDimSetEntry."Dimension Code" := JobTaskDimension."Dimension Code";
TempDimSetEntry."Dimension Value Code" := JobTaskDimension."Dimension Value Code";
TempDimSetEntry."Dimension Value ID" := DimValue."Dimension Value ID";
TempDimSetEntry.Insert(true);
until JobTaskDimension.Next() = 0;
NewDimSetID := GetDimensionSetID(TempDimSetEntry);
UpdateGlobalDimFromDimSetID(NewDimSetID, GlobalDimVal1, GlobalDimVal2);
end;
end;
/// <summary>
/// Updates general journal line with dimension set ID and corresponding shortcut dimension codes.
/// </summary>
/// <param name="GenJnlLine">General journal line to update with dimensions</param>
/// <param name="DimSetID">Dimension set ID to assign to the journal line</param>
procedure UpdateGenJnlLineDim(var GenJnlLine: Record "Gen. Journal Line"; DimSetID: Integer)
begin
GenJnlLine."Dimension Set ID" := DimSetID;
UpdateGlobalDimFromDimSetID(
GenJnlLine."Dimension Set ID",
GenJnlLine."Shortcut Dimension 1 Code", GenJnlLine."Shortcut Dimension 2 Code");
OnAfterUpdateGenJnlLineDim(GenJnlLine, DimSetID);
end;
/// <summary>
/// Updates general journal line dimensions from corresponding customer ledger entry.
/// </summary>
/// <param name="GenJnlLine">General journal line to update with dimensions</param>
/// <param name="DtldCustLedgEntry">Detailed customer ledger entry containing dimension reference</param>
procedure UpdateGenJnlLineDimFromCustLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; DtldCustLedgEntry: Record "Detailed Cust. Ledg. Entry")
var
CustLedgEntry: Record "Cust. Ledger Entry";
begin
if DtldCustLedgEntry."Cust. Ledger Entry No." <> 0 then begin
CustLedgEntry.Get(DtldCustLedgEntry."Cust. Ledger Entry No.");
UpdateGenJnlLineDim(GenJnlLine, CustLedgEntry."Dimension Set ID");
end;
end;
/// <summary>
/// Updates general journal line dimensions from corresponding vendor ledger entry.
/// </summary>
/// <param name="GenJnlLine">General journal line to update with dimensions</param>
/// <param name="DtldVendLedgEntry">Detailed vendor ledger entry containing dimension reference</param>
procedure UpdateGenJnlLineDimFromVendLedgEntry(var GenJnlLine: Record "Gen. Journal Line"; DtldVendLedgEntry: Record "Detailed Vendor Ledg. Entry")
var
VendLedgEntry: Record "Vendor Ledger Entry";
begin
if DtldVendLedgEntry."Vendor Ledger Entry No." <> 0 then begin
VendLedgEntry.Get(DtldVendLedgEntry."Vendor Ledger Entry No.");
UpdateGenJnlLineDim(GenJnlLine, VendLedgEntry."Dimension Set ID");
end;
end;
/// <summary>
/// Gets dimension set entry default dimensions. Method is obsolete and clears dimension set entries.
/// </summary>
/// <param name="DimSetEntry">Dimension set entry record to clear</param>
procedure GetDimSetEntryDefaultDim(var DimSetEntry: Record "Dimension Set Entry")
begin
// Obsolete method
DimSetEntry.DeleteAll();
end;
/// <summary>
/// Inserts table object into temporary AllObjWithCaption record if not obsolete.
/// </summary>
/// <param name="TempAllObjWithCaption">Temporary record to insert object information</param>
/// <param name="TableID">Table ID to check and insert</param>
procedure InsertObject(var TempAllObjWithCaption: Record AllObjWithCaption temporary; TableID: Integer)
var
AllObjWithCaption: Record AllObjWithCaption;
begin
if IsObsolete(TableID) then
exit;
if AllObjWithCaption.Get(AllObjWithCaption."Object Type"::Table, TableID) then begin
TempAllObjWithCaption := AllObjWithCaption;
if TempAllObjWithCaption.Insert() then;
end;
end;
local procedure IsObsolete(TableID: Integer): Boolean
var
TableMetadata: Record "Table Metadata";
begin
if TableMetadata.Get(TableID) then
exit(TableMetadata.ObsoleteState = TableMetadata.ObsoleteState::Removed);
end;
/// <summary>
/// Gets consolidated dimension filter by combining dimension filter with dimension codes.
/// </summary>
/// <param name="Dimension">Dimension record to filter and process</param>
/// <param name="DimFilter">Dimension filter text to apply</param>
/// <returns>Consolidated dimension filter including original filter and dimension codes</returns>
procedure GetConsolidatedDimFilterByDimFilter(var Dimension: Record Dimension; DimFilter: Text) ConsolidatedDimFilter: Text
begin
Dimension.SetFilter("Consolidation Code", DimFilter);
ConsolidatedDimFilter += DimFilter;
if Dimension.FindSet() then
repeat
ConsolidatedDimFilter += '|' + Dimension.Code;
until Dimension.Next() = 0;
end;
/// <summary>
/// Resolves dimension value filter by expanding with totaling values.
/// </summary>
/// <param name="DimValueFilter">Dimension value filter to resolve and expand</param>
/// <param name="DimensionCode">Dimension code for which to resolve values</param>
procedure ResolveDimValueFilter(var DimValueFilter: Text; DimensionCode: Code[20])
begin
DimValueFilter := GetDimValuesWithTotalings(DimValueFilter, DimensionCode);
end;
local procedure GetDimValuesWithTotalings(DimValueFilter: Text; DimensionCode: Code[20]) ResultTxt: Text
var
FilterChars: Text;
DimParam: Text;
CharTxt: Text;
NextCharTxt: Text;
SingleQuoteCharTxt: Text;
DimFilterLen: Integer;
i: Integer;
begin
if DimensionCode = '' then
exit(DimValueFilter);
if DimValueFilter = '' then
exit(DimValueFilter);
FilterChars := '()|"&@<>=.';
SingleQuoteCharTxt := '''';
DimValueFilter := UpperCase(DimValueFilter);
DimFilterLen := StrLen(DimValueFilter);
i := 1;
repeat
DimParam := '';
CharTxt := Format(DimValueFilter[i]);
while (StrPos(FilterChars, CharTxt) > 0) and (i <= DimFilterLen) do begin
ResultTxt += CharTxt;
i += 1;
CharTxt := Format(DimValueFilter[i]);
end;
if CharTxt = SingleQuoteCharTxt then begin
repeat
DimParam += CharTxt;
i += 1;
CharTxt := Format(DimValueFilter[i]);
NextCharTxt := Format(DimValueFilter[i + 1]);
until ((CharTxt = SingleQuoteCharTxt) and (NextCharTxt <> SingleQuoteCharTxt)) or (i > DimFilterLen);
DimParam += CharTxt;
i += 1;
end else
while (StrPos(FilterChars, CharTxt) = 0) and (i <= DimFilterLen) do begin
DimParam += CharTxt;
i += 1;
CharTxt := Format(DimValueFilter[i]);
end;
if DimParam <> '' then
ResultTxt += ParseDimParam(DimParam, DimensionCode);
until i > DimFilterLen;
end;
local procedure ParseDimParam(DimValueFilter: Text; DimensionCode: Code[20]) ResultTxt: Text
var
DimensionValue: Record "Dimension Value";
TempDimensionValue: Record "Dimension Value" temporary;
CheckStr: Text;
begin
OnBeforeParseDimParam(DimensionValue);
// Possible input values: blank filter, code or code with *
if DelChr(DimValueFilter) = '' then
exit(DimValueFilter);
DimensionValue.SetRange("Dimension Code", DimensionCode);
DimensionValue.SetFilter(Code, DimValueFilter);
DimensionValue.SetFilter(Totaling, '<>%1', '');
if DimensionValue.IsEmpty() then
exit(DimValueFilter);
AddTempDimValueFromTotaling(TempDimensionValue, CheckStr, DimensionCode, DimValueFilter);
OnParseDimParamOnBeforeTempDimensionValueFindSet(TempDimensionValue);
if TempDimensionValue.FindSet() then
repeat
ResultTxt += TempDimensionValue.Code + '|'
until TempDimensionValue.Next() = 0;
if ResultTxt <> '' then
ResultTxt := '(' + CopyStr(ResultTxt, 1, StrLen(ResultTxt) - 1) + ')';
end;
local procedure AddTempDimValueFromTotaling(var TempDimensionValue: Record "Dimension Value" temporary; var CheckStr: Text; DimensionCode: Code[20]; Totaling: Text)
var
DimensionValue: Record "Dimension Value";
begin
if StrPos(CheckStr, '(' + Totaling + ')') > 0 then
exit;
CheckStr += '(' + Totaling + ')';
DimensionValue.SetRange("Dimension Code", DimensionCode);
DimensionValue.SetFilter(Code, Totaling);
if DimensionValue.FindSet() then
repeat
if DimensionValue.Totaling <> '' then
AddTempDimValueFromTotaling(TempDimensionValue, CheckStr, DimensionCode, DimensionValue.Totaling)
else begin
TempDimensionValue := DimensionValue;
if TempDimensionValue.Insert() then;
end;
until DimensionValue.Next() = 0;
end;
/// <summary>
/// Determines the visibility of shortcut dimension fields based on General Ledger Setup configuration.
/// Returns boolean values for each of the eight shortcut dimension fields indicating whether they should be visible in the UI.
/// </summary>
/// <param name="DimVisible1">Returns true if shortcut dimension 1 is configured and should be visible</param>
/// <param name="DimVisible2">Returns true if shortcut dimension 2 is configured and should be visible</param>
/// <param name="DimVisible3">Returns true if shortcut dimension 3 is configured and should be visible</param>
/// <param name="DimVisible4">Returns true if shortcut dimension 4 is configured and should be visible</param>
/// <param name="DimVisible5">Returns true if shortcut dimension 5 is configured and should be visible</param>
/// <param name="DimVisible6">Returns true if shortcut dimension 6 is configured and should be visible</param>
/// <param name="DimVisible7">Returns true if shortcut dimension 7 is configured and should be visible</param>
/// <param name="DimVisible8">Returns true if shortcut dimension 8 is configured and should be visible</param>
procedure UseShortcutDims(var DimVisible1: Boolean; var DimVisible2: Boolean; var DimVisible3: Boolean; var DimVisible4: Boolean; var DimVisible5: Boolean; var DimVisible6: Boolean; var DimVisible7: Boolean; var DimVisible8: Boolean)
var
GLSetup: Record "General Ledger Setup";
begin
GLSetup.Get();
DimVisible1 := GLSetup."Shortcut Dimension 1 Code" <> '';
DimVisible2 := GLSetup."Shortcut Dimension 2 Code" <> '';
DimVisible3 := GLSetup."Shortcut Dimension 3 Code" <> '';
DimVisible4 := GLSetup."Shortcut Dimension 4 Code" <> '';
DimVisible5 := GLSetup."Shortcut Dimension 5 Code" <> '';
DimVisible6 := GLSetup."Shortcut Dimension 6 Code" <> '';
DimVisible7 := GLSetup."Shortcut Dimension 7 Code" <> '';
DimVisible8 := GLSetup."Shortcut Dimension 8 Code" <> '';
OnAfterUseShortcutDims(DimVisible1, DimVisible2, DimVisible3, DimVisible4, DimVisible5, DimVisible6, DimVisible7, DimVisible8);
end;
/// <summary>
/// Opens page for managing allowed dimension values per account with buffer synchronization.
/// </summary>
/// <param name="DefaultDimension">Default dimension record to manage allowed values for</param>
procedure OpenAllowedDimValuesPerAccount(var DefaultDimension: Record "Default Dimension")
var
DimValuePerAccount: Record "Dim. Value per Account";
TempDimValuePerAccount: Record "Dim. Value per Account" temporary;
DimAllowedValuesPerAcc: Page "Dim. Allowed Values per Acc.";
begin
SyncDimValuePerAccountWithDimValues(DefaultDimension);
Commit();
FillDimValuePerAccountBuffer(DefaultDimension, TempDimValuePerAccount);
DimAllowedValuesPerAcc.SetBufferData(TempDimValuePerAccount);
DimAllowedValuesPerAcc.LookupMode(true);
if DimAllowedValuesPerAcc.RunModal() = Action::LookupOK then begin
DimAllowedValuesPerAcc.GetBufferData(TempDimValuePerAccount);
UpdateDefaultDimensionAllowedValuesFromBuffer(DimValuePerAccount, TempDimValuePerAccount);
DefaultDimension.UpdateDefaultDimensionAllowedValuesFilter();
end;
end;
local procedure UpdateDefaultDimensionAllowedValuesFromBuffer(var DimValuePerAccount: Record "Dim. Value per Account"; var TempDimValuePerAccount: Record "Dim. Value per Account" temporary)
begin
if TempDimValuePerAccount.FindSet() then
repeat
if DimValuePerAccount.Get(TempDimValuePerAccount."Table ID", TempDimValuePerAccount."No.", TempDimValuePerAccount."Dimension Code", TempDimValuePerAccount."Dimension Value Code") then begin
DimValuePerAccount.Allowed := TempDimValuePerAccount.Allowed;
DimValuePerAccount.Modify();
end;
until TempDimValuePerAccount.Next() = 0;
end;
/// <summary>
/// Fills temporary dimension value per account buffer from existing records or dimension values.
/// </summary>
/// <param name="DefaultDimension">Default dimension record to get account and dimension information</param>
/// <param name="TempDimValuePerAccount">Temporary buffer to fill with dimension value per account data</param>
procedure FillDimValuePerAccountBuffer(var DefaultDimension: Record "Default Dimension"; var TempDimValuePerAccount: Record "Dim. Value per Account" temporary)
var
DimValuePerAccount: Record "Dim. Value per Account";
DimValue: Record "Dimension Value";
begin
DimValuePerAccount.SetRange("Table ID", DefaultDimension."Table ID");
DimValuePerAccount.SetRange("No.", DefaultDimension."No.");
DimValuePerAccount.SetRange("Dimension Code", DefaultDimension."Dimension Code");
if DimValuePerAccount.FindSet() then
repeat
TempDimValuePerAccount := DimValuePerAccount;
TempDimValuePerAccount.Insert();
until DimValuePerAccount.Next() = 0
else begin
DimValue.SetRange("Dimension Code", DefaultDimension."Dimension Code");
if DimValue.FindSet() then
repeat
TempDimValuePerAccount.Init();
TempDimValuePerAccount."Dimension Code" := DimValue."Dimension Code";
TempDimValuePerAccount."Dimension Value Code" := DimValue.Code;
TempDimValuePerAccount."Table ID" := DefaultDimension."Table ID";
TempDimValuePerAccount."No." := DefaultDimension."No.";
TempDimValuePerAccount.Insert();
until DimValue.Next() = 0;
end;
end;
/// <summary>
/// Synchronizes dimension value per account records with dimension values.
/// Creates dimension value per account entries for all dimension values in the specified dimension.
/// </summary>
/// <param name="DefaultDimension">Default dimension record containing the dimension code to synchronize</param>
procedure SyncDimValuePerAccountWithDimValues(var DefaultDimension: Record "Default Dimension")
var
DimValuePerAccount: Record "Dim. Value per Account";
DimValue: Record "Dimension Value";
begin
DimValue.SetRange("Dimension Code", DefaultDimension."Dimension Code");
if DimValue.FindSet() then
repeat
if not DimValuePerAccount.Get(DefaultDimension."Table ID", DefaultDimension."No.", DefaultDimension."Dimension Code", DimValue.Code) then begin
DimValuePerAccount.Init();
DimValuePerAccount."Dimension Code" := DimValue."Dimension Code";
DimValuePerAccount."Dimension Value Code" := DimValue.Code;
DimValuePerAccount."Table ID" := DefaultDimension."Table ID";
DimValuePerAccount."No." := DefaultDimension."No.";
DimValuePerAccount.Insert();
end;
until DimValue.Next() = 0;
end;
/// <summary>
/// Synchronizes temporary dimension value per account records with dimension values.
/// Creates temporary dimension value per account entries for all dimension values in the specified dimension.
/// </summary>
/// <param name="DefaultDimension">Default dimension record containing the dimension code to synchronize</param>
/// <param name="TempDimValuePerAccount">Temporary buffer to populate with dimension value per account records</param>
procedure SyncTempDimValuePerAccountWithDimValues(var DefaultDimension: Record "Default Dimension"; var TempDimValuePerAccount: Record "Dim. Value per Account" temporary)
var
DimValue: Record "Dimension Value";
begin
DimValue.SetRange("Dimension Code", DefaultDimension."Dimension Code");
if DimValue.FindSet() then
repeat
if not TempDimValuePerAccount.Get(DefaultDimension."Table ID", DefaultDimension."No.", DefaultDimension."Dimension Code", DimValue.Code) then begin
TempDimValuePerAccount.Init();
TempDimValuePerAccount."Dimension Code" := DimValue."Dimension Code";
TempDimValuePerAccount."Dimension Value Code" := DimValue.Code;
TempDimValuePerAccount."Table ID" := DefaultDimension."Table ID";
TempDimValuePerAccount."No." := DefaultDimension."No.";
TempDimValuePerAccount.Insert();
end;
until DimValue.Next() = 0;
end;
/// <summary>
/// Opens the allowed dimension values per account page for multiple dimension selection.
/// Provides user interface for selecting allowed dimension values for specific account configurations.
/// </summary>
/// <param name="DefaultDimension">Default dimension record containing the configuration context</param>
/// <param name="TempDimValuePerAccount">Temporary buffer containing dimension value per account data</param>
procedure OpenAllowedDimValuesPerAccountDimMultiple(var DefaultDimension: Record "Default Dimension"; var TempDimValuePerAccount: Record "Dim. Value per Account" temporary)
var
DimAllowedValuesPerAcc: Page "Dim. Allowed Values per Acc.";
begin
SyncTempDimValuePerAccountWithDimValues(DefaultDimension, TempDimValuePerAccount);
TempDimValuePerAccount.Reset();
TempDimValuePerAccount.SetRange("Table ID", DefaultDimension."Table ID");
TempDimValuePerAccount.SetRange("No.", DefaultDimension."No.");
TempDimValuePerAccount.SetRange("Dimension Code", DefaultDimension."Dimension Code");
DimAllowedValuesPerAcc.SetBufferData(TempDimValuePerAccount);
DimAllowedValuesPerAcc.LookupMode(true);
if DimAllowedValuesPerAcc.RunModal() = Action::LookupOK then begin
DimAllowedValuesPerAcc.GetBufferData(TempDimValuePerAccount);
DefaultDimension.UpdateDefaultDimensionAllowedValuesFilter();
end;
end;
/// <summary>
/// Adds a dimension value to the allowed values filter for default dimensions.
/// Updates default dimension configurations to include the specified dimension value as allowed.
/// </summary>
/// <param name="DimensionValue">Dimension value record to add to allowed values</param>
procedure AddDefaultDimensionAllowedDimensionValue(DimensionValue: Record "Dimension Value")
var
DefaultDimension: Record "Default Dimension";
ConfirmManagement: Codeunit "Confirm Management";
Confirmed: Boolean;
IsHandled: Boolean;
ConfirmHandled: Boolean;
begin
IsHandled := false;
OnBeforeAddDefaultDimensionAllowedDimensionValue(DimensionValue, IsHandled);
if IsHandled then
exit;
DefaultDimension.SetRange("Dimension Code", DimensionValue."Dimension Code");
DefaultDimension.SetRange("Value Posting", DefaultDimension."Value Posting"::"Code Mandatory");
DefaultDimension.SetFilter("Allowed Values Filter", '<>%1', '');
OnAddDefaultDimensionAllowedDimensionValueOnAfterSetFilters(DefaultDimension);
if DefaultDimension.IsEmpty() then
exit;
OnAllowedDimensionValueConfirm(DimensionValue, DefaultDimension, Confirmed, ConfirmHandled);
if not ConfirmHandled then
Confirmed := ConfirmManagement.GetResponseOrDefault(StrSubstNo(AllowedDimensionValueConfirmTxt, DimensionValue.Code, DefaultDimension.FieldCaption("Allowed Values Filter"), DefaultDimension.Count()), false);
DefaultDimension.FindSet(true);
repeat
DefaultDimension.CreateDimValuePerAccountFromDimValue(DimensionValue, Confirmed);
if Confirmed then
DefaultDimension.AddDimensionValueToAllowedFilter(DimensionValue.Code);
until DefaultDimension.Next() = 0;
end;
/// <summary>
/// Updates default dimension allowed values filter when dimension values change.
/// Refreshes allowed values filter for all default dimensions using the specified dimension.
/// </summary>
/// <param name="DimensionValue">Dimension value record that has been modified</param>
procedure UpdateDefaultDimensionAllowedDimensionValues(DimensionValue: Record "Dimension Value")
var
DefaultDimension: Record "Default Dimension";
begin
DefaultDimension.SetRange("Dimension Code", DimensionValue."Dimension Code");
DefaultDimension.SetRange("Value Posting", DefaultDimension."Value Posting"::"Code Mandatory");
DefaultDimension.SetFilter("Allowed Values Filter", '<>%1', '');
if DefaultDimension.FindSet(true) then
repeat
DefaultDimension.UpdateDefaultDimensionAllowedValuesFilter();
until DefaultDimension.Next() = 0;
end;
/// <summary>
/// Validates that at least one allowed value is selected for dimension value per account configuration.
/// Throws an error if no allowed values are marked as selected.
/// </summary>
/// <param name="DimValuePerAccount">Dimension value per account record to validate</param>
procedure CheckIfNoAllowedValuesSelected(var DimValuePerAccount: Record "Dim. Value per Account")
begin
DimValuePerAccount.SetRange(Allowed, true);
if DimValuePerAccount.IsEmpty() then
Error(NoAllowedValuesSelectedErr);
end;
local procedure InsertTempDimBufEntry(var TempDimBuf: Record "Dimension Buffer" temporary; TableId: Integer; EntryNo: Integer; DimCode: Code[20]; DimValueCode: Code[20])
begin
TempDimBuf.Init();
TempDimBuf."Table ID" := TableId;
TempDimBuf."Entry No." := EntryNo;
TempDimBuf."Dimension Code" := DimCode;
TempDimBuf."Dimension Value Code" := DimValueCode;
TempDimBuf.Insert();
end;
/// <summary>
/// Adds dimension source to default dimension source list.
/// </summary>
/// <param name="DefaultDimSource">List of default dimension sources to add to</param>
/// <param name="TableId">Table ID for the dimension source</param>
/// <param name="No">Number/code for the dimension source</param>
procedure AddDimSource(var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; TableId: Integer; No: Code[20])
var
DimSource: Dictionary of [Integer, Code[20]];
begin
DimSource.Add(TableId, No);
DefaultDimSource.Add(DimSource);
end;
/// <summary>
/// Adds dimension source to default dimension source list with position control.
/// </summary>
/// <param name="DefaultDimSource">List of default dimension sources to add to</param>
/// <param name="TableId">Table ID for the dimension source</param>
/// <param name="No">Number/code for the dimension source</param>
/// <param name="FirstPos">True to insert at first position, false to add at end</param>
procedure AddDimSource(var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; TableId: Integer; No: Code[20]; FirstPos: Boolean)
var
DimSource: Dictionary of [Integer, Code[20]];
begin
DimSource.Add(TableId, No);
if FirstPos then
DefaultDimSource.Insert(1, DimSource)
else
DefaultDimSource.Add(DimSource);
end;
/// <summary>
/// Checks if default dimensions are defined for a specific table and record combination.
/// Returns true if any default dimension records exist for the table and record specified.
/// </summary>
/// <param name="TableValuePair">Dictionary containing table ID and record number pair to check</param>
/// <returns>True if default dimensions exist for the table and record, false otherwise</returns>
procedure IsDefaultDimDefinedForTable(TableValuePair: Dictionary of [Integer, Code[20]]): Boolean
var
DefaultDim: Record "Default Dimension";
begin
if TableValuePair.Count = 0 then exit(true);
DefaultDim.SetRange("Table ID", TableValuePair.Keys.Get(1));
DefaultDim.SetFilter("No.", '%1|%2', TableValuePair.Values.Get(1), '');
DefaultDim.SetFilter("Dimension Value Code", '<>%1', '');
if not DefaultDim.IsEmpty() then exit(true);
end;
local procedure DefDimPrioritiesNotExist(SourceCode: Code[20]): Boolean
var
DefaultDimPriority: Record "Default Dimension Priority";
begin
DefaultDimPriority.SetRange("Source Code", SourceCode);
if DefaultDimPriority.IsEmpty() then
exit(true);
end;
local procedure InitializeDefaultDimPrioritiesMissingNotification(SourceCode: Code[20])
var
MyNotifications: Record "My Notifications";
DefaultDimPrioritiesNotification: Notification;
begin
if not MyNotifications.IsEnabled(InstructionMgt.GetDefaultDimPrioritiesNotificationId()) then
exit;
DefaultDimPrioritiesNotification.Id := InstructionMgt.GetDefaultDimPrioritiesNotificationId();
DefaultDimPrioritiesNotification.Recall();
DefaultDimPrioritiesNotification.Message(StrSubstNo(DefaultDimPrioritiesMissingLbl, SourceCode));
DefaultDimPrioritiesNotification.Scope := NotificationScope::LocalScope;
DefaultDimPrioritiesNotification.SetData('SourceCode', SourceCode);
DefaultDimPrioritiesNotification.AddAction(HideNotificationTxt, Codeunit::DimensionManagement, 'DontNotifyCurrentUserAgain');
DefaultDimPrioritiesNotification.AddAction(OpenDefaultDimPrioritiesLbl, Codeunit::DimensionManagement, 'OpenDefaultDimPriorities');
DefaultDimPrioritiesNotification.Send();
end;
/// <summary>
/// Disables current user notification for default dimension priorities.
/// </summary>
/// <param name="Notification">Notification to disable for current user</param>
procedure DontNotifyCurrentUserAgain(Notification: Notification)
var
MyNotifications: Record "My Notifications";
begin
if not MyNotifications.Disable(InstructionMgt.GetDefaultDimPrioritiesNotificationId()) then
MyNotifications.InsertDefault(InstructionMgt.GetDefaultDimPrioritiesNotificationId(), InstructionMgt.GetDefaultDimPrioritiesTxt(),
InstructionMgt.GetDefaultDimPrioritiesDescriptionTxt(), false);
end;
/// <summary>
/// Opens default dimension priorities page with source code from notification data.
/// </summary>
/// <param name="DefaultDimPrioritiesNotification">Notification containing source code data</param>
procedure OpenDefaultDimPriorities(DefaultDimPrioritiesNotification: Notification)
var
DefaultDimPriority: Record "Default Dimension Priority";
begin
DefaultDimPriority."Source Code" := CopyStr(DefaultDimPrioritiesNotification.GetData('SourceCode'), 1, MaxStrLen(DefaultDimPriority."Source Code"));
Page.Run(Page::"Default Dimension Priorities", DefaultDimPriority);
end;
/// <summary>
/// Checks if any default dimensions have Code Mandatory value posting for given table IDs and numbers.
/// </summary>
/// <param name="TableID">Array of table IDs to check for default dimensions</param>
/// <param name="No">Array of numbers corresponding to table IDs</param>
/// <returns>True if any default dimension has Code Mandatory value posting, false otherwise</returns>
procedure CheckDefaultDimensionHasCodeMandatory(TableID: array[10] of Integer; No: array[10] of Code[20]) CodeMandatory: Boolean
var
TempDefaultDim: Record "Default Dimension" temporary;
begin
CollectDefaultDimsToCheck(TableID, No, TempDefaultDim);
TempDefaultDim.Reset();
TempDefaultDim.SetRange("Value Posting", TempDefaultDim."Value Posting"::"Code Mandatory");
if not TempDefaultDim.IsEmpty() then
CodeMandatory := true;
exit(CodeMandatory);
end;
/// <summary>
/// Sets flag to skip change dimensions confirmation question.
/// </summary>
/// <param name="Skip">True to skip confirmation question, false to show question</param>
procedure SetSkipChangeDimensionsQst(Skip: Boolean)
begin
SkipChangeDimensionsQst := Skip;
end;
/// <summary>
/// Sets flag to skip dimension updates.
/// </summary>
/// <param name="Skip">True to skip dimension updates, false to perform updates</param>
procedure SetSkipUpdateDimensions(Skip: Boolean)
begin
SkipUpdateDimensions := Skip;
end;
/// <summary>
/// Gets flag indicating whether dimension updates should be skipped.
/// </summary>
/// <returns>True if dimension updates should be skipped, false otherwise</returns>
procedure GetSkipUpdateDimensions(): Boolean
begin
exit(SkipUpdateDimensions);
end;
/// <summary>
/// Adds or updates the dimension value for the specified dimension set.
/// </summary>
/// <param name="DimSetID">Specifies the dimension set that is going to be updated.</param>
/// <param name="DimensionCode">Specifies the code of the dimension that is going to be updated.</param>
/// <param name="DimensionValueCode">Specifies the code of the dimension value that is going to set in the dimension set.</param>
/// <param name="AutoCreateMissingDimension">Specifies whether the dimension will be created if it doesn't exist.</param>
/// <param name="AutoCreateMissingDimensionValue">Specifies whether the dimension value will be created if it doesn't exist.</param>
/// <returns>Returns the new dimension set ID.</returns>
procedure SetDimensionValue(DimSetID: Integer; DimensionCode: Code[20]; DimensionValueCode: Code[20]; AutoCreateMissingDimension: Boolean; AutoCreateMissingDimensionValue: Boolean): Integer
begin
exit(SetDimensionValue(DimSetID, DimensionCode, '', DimensionValueCode, '', AutoCreateMissingDimension, AutoCreateMissingDimensionValue));
end;
/// <summary>
/// Adds or updates the dimension value for the specified dimension set. Any dimension or dimension value that doesn't exist will be created automatically.
/// </summary>
/// <param name="DimSetID">Specifies the dimension set that is going to be updated.</param>
/// <param name="DimensionCode">Specifies the code of the dimension that is going to be updated.</param>
/// <param name="DimensionValueCode">Specifies the code of the dimension value that is going to set in the dimension set.</param>
/// <param name="DimensionName">Specifies the name of the dimension, if the the dimension doesn't exist yet.</param>
/// <param name="DimensionValueName">Specifies the name of the dimension value, if the dimension value doesn't exist yet.</param>
/// <returns>Returns the new dimension set ID.</returns>
procedure SetDimensionValue(DimSetID: Integer; DimensionCode: Code[20]; DimensionValueCode: Code[20]; DimensionName: Text[30]; DimensionValueName: Text[50]): Integer
begin
exit(SetDimensionValue(DimSetID, DimensionCode, DimensionName, DimensionValueCode, DimensionValueName, true, true));
end;
/// <summary>
/// Adds or updates the dimension value for the specified dimension set.
/// </summary>
/// <param name="DimSetID">Specifies the dimension set that is going to be updated.</param>
/// <param name="DimensionCode">Specifies the code of the dimension that is going to be updated.</param>
/// <param name="DimensionValueCode">Specifies the code of the dimension value that is going to set in the dimension set.</param>
/// <param name="DimensionName">Specifies the name of the dimension, if the the dimension doesn't exist yet.</param>
/// <param name="DimensionValueName">Specifies the name of the dimension value, if the the dimension value doesn't exist yet.</param>
/// <param name="AutoCreateMissingDimension">Specifies whether the dimension will be create if it doesn't exist.</param>
/// <param name="AutoCreateMissingDimensionValue">Specifies whether the dimension value will be create if doesn't exist.</param>
/// <returns>Returns the new dimension set ID.</returns>
procedure SetDimensionValue(DimSetID: Integer; DimensionCode: Code[20]; DimensionName: Text[30]; DimensionValueCode: Code[20]; DimensionValueName: Text[50]; AutoCreateMissingDimension: Boolean; AutoCreateMissingDimensionValue: Boolean): Integer
var
TempDimensionSetEntry: Record "Dimension Set Entry" temporary;
Dimension: Record Dimension;
DimensionValue: Record "Dimension Value";
DimensionManagement: Codeunit DimensionManagement;
begin
if '' in [DimensionCode, DimensionValueCode] then
exit(DimSetID);
if AutoCreateMissingDimension then
if not Dimension.Get(DimensionCode) then
CreateDimension(Dimension, DimensionCode, DimensionName);
if AutoCreateMissingDimensionValue then
if not DimensionValue.Get(DimensionCode, DimensionValueCode) then
CreateDimensionValue(DimensionValue, DimensionCode, DimensionValueCode, DimensionValueName);
DimensionManagement.GetDimensionSet(TempDimensionSetEntry, DimSetID);
if not TempDimensionSetEntry.Get(DimSetID, DimensionCode) then begin
TempDimensionSetEntry.Init();
TempDimensionSetEntry.Validate("Dimension Set ID", DimSetID);
TempDimensionSetEntry.Validate("Dimension Code", DimensionCode);
TempDimensionSetEntry.Insert(true);
end;
TempDimensionSetEntry.Validate("Dimension Value Code", DimensionValueCode);
TempDimensionSetEntry.Modify(true);
exit(DimensionManagement.GetDimensionSetID(TempDimensionSetEntry));
end;
local procedure CreateDimension(var Dimension: Record Dimension; DimensionCode: Code[20]; DimensionName: Text[30])
begin
Dimension.Init();
Dimension.Validate("Code", DimensionCode);
Dimension.Validate(Name, DimensionName);
Dimension.Insert(true);
end;
local procedure CreateDimensionValue(var DimensionValue: Record "Dimension Value"; DimensionCode: Code[20]; DimensionValueCode: Code[20]; DimensionValueName: Text[50])
begin
DimensionValue.Init();
DimensionValue.Validate("Code", DimensionValueCode);
DimensionValue.Validate("Dimension Code", DimensionCode);
DimensionValue.Validate(Name, DimensionValueName);
DimensionValue.Insert(true);
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckDimValuePosting(TableID: array[10] of Integer; No: array[10] of Code[20]; var TempDefaultDim: Record "Default Dimension" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckDimValue(DimCode: Code[20]; DimValCode: Code[20]; var Result: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterConvertDimtoICDim(FromDim: Code[20]; var ICDimCode: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterConvertDimValuetoICDimVal(FromDimCode: Code[20]; FromDimValue: Code[20]; var ICDimValueCode: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterConvertICDimtoDim(FromICDimCode: Code[20]; var DimCode: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterConvertICDimValuetoDimValue(FromICDimCode: Code[20]; FromICDimValue: Code[20]; var DimValueCode: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCreateDimForJobJournalLineWithHigherPrioritiesProcedure(JobJournalLine: Record "Job Journal Line"; CurrFieldNo: Integer; var DimensionSetID: Integer; var DimValue1: Code[20]; var DimValue2: Code[20]; SourceCode: Code[10]; PriorityTableID: Integer; var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; var HighPriorityDefaultDimSource: List of [Dictionary of [Integer, Code[20]]])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterEditDimensionSet2(var DimSetID: Integer; var GlobalDimVal1: Code[20]; var GlobalDimVal2: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterDeleteDefaultDim(TableID: Integer; No: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterSetupObjectNoList(var TempAllObjWithCaption: Record AllObjWithCaption temporary)
begin
end;
[IntegrationEvent(true, false)]
local procedure OnAfterDefaultDimObjectNoWithoutGlobalDimsList(var TempAllObjWithCaption: Record AllObjWithCaption temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterIsDefaultDimTable(TableID: Integer; var Result: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterSetSourceCodeWithVar(TableID: Integer; RecordVar: Variant; var SourceCode: Code[10])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterUpdateGenJnlLineDim(var GenJournalLine: Record "Gen. Journal Line"; DimSetID: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterUpdateDefaultDim(TableID: Integer; No: Code[20]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterUpdateJobTaskDim(DefaultDimension: Record "Default Dimension")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterValidateDimValueCode(FieldNumber: Integer; var ShortcutDimCode: Code[20]; var GLSetupShortcutDimCode: array[8] of Code[20]; DimensionValue: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterValidateShortcutDimValues(FieldNumber: Integer; var ShortcutDimCode: Code[20]; var DimSetID: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAddDefaultDimensionAllowedDimensionValueOnAfterSetFilters(var DefaultDimension: Record "Default Dimension")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeAddDefaultDimensionAllowedDimensionValue(DimensionValue: Record "Dimension Value"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckDim(DimCode: Code[20]; var Result: Boolean; var IsHandled: Boolean; var Dimension: Record Dimension)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckDimComb(var DimensionCombination: Record "Dimension Combination"; var TempDimensionBuffer: Record "Dimension Buffer" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckDimValueComb(var DimensionValueCombination: Record "Dimension Value Combination")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckDimValue(DimCode: Code[20]; DimValCode: Code[20]; var Result: Boolean; var IsHandled: Boolean; var DimVal: Record "Dimension Value");
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckDimValueAllowed(var DimensionValue: Record "Dimension Value"; var IsHandled: Boolean; var Result: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckDimValuePosting(TableID: array[10] of Integer; No: array[10] of Code[20]; DimSetID: Integer; var IsChecked: Boolean; var IsHandled: Boolean; var DimensionSetEntry: Record "Dimension Set Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckICDim(ICDimCode: Code[20]; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeGetDimensionSetIDProcedure(var DimensionSetEntry: Record "Dimension Set Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckICDimValue(ICDimCode: Code[20]; ICDimValCode: Code[20]; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckValuePosting(TableID: array[10] of Integer; No: array[10] of Code[20]; var TempDimBuf: Record "Dimension Buffer" temporary; var IsChecked: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeConvertDimValuetoICDimVal(var DimValue: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCreateDimSetIDFromICDocDim(var DimValue: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCreateDimSetIDFromICJnlLineDim(var DimValue: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyDimBufToDimSetEntry(var DimValue: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCreateDimSetIDFromDimBuf(var DimValue: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeDefaultDimOnInsert(var DefaultDimension: Record "Default Dimension"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeDefaultDimOnDelete(var DefaultDimension: Record "Default Dimension"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeDefaultDimOnModify(var DefaultDimension: Record "Default Dimension"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeGetDimensionSet(var TempDimensionSetEntry: Record "Dimension Set Entry" temporary; var DimSetID: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeEditDimensionSet(DimSetID: Integer; NewCaption: Text[250]; var NewDimSetID: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeEditDimensionSet2(DimSetID: Integer; NewCaption: Text[250]; var GlobalDimVal1: Code[20]; var GlobalDimVal2: Code[20]; var NewDimSetID: Integer; var IsHandled: Boolean; RecVariant: Variant)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeGetDeltaDimSetID(var DimSetID: Integer; NewParentDimSetID: Integer; OldParentDimSetID: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeGetTableIDsForHigherPrioritiesProcedure(TableNo: Integer; RecVar: Variant; var FieldNo: Integer; var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeInsertJobTaskDim(JobNo: Code[20]; JobTaskNo: Code[20]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20]; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeLookupDimValueCode(FieldNumber: Integer; var ShortcutDimCode: Code[20]; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeLookupDimValueCodeNoUpdate(FieldNumber: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeParseDimParam(var DimensionValue: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeSaveDefaultDim(TableID: Integer; No: Code[20]; FieldNumber: Integer; ShortcutDimCode: Code[20]; var IsHandled: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeSetupObjectNoList(var TempDimField: Record Field temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdateDefaultDim(TableID: Integer; No: Code[20]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20]; var IsHandled: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeValidateDimValueCode(FieldNumber: Integer; var ShortcutDimCode: Code[20]; var IsHandled: Boolean; var GLSetupShortcutDimCode: array[8] of Code[20]; var DimVal: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeValidateShortcutDimValues(var DimVal: Record "Dimension Value"; FieldNumber: Integer; var ShortcutDimCode: Code[20]; var DimSetID: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnParseDimParamOnBeforeTempDimensionValueFindSet(var DimensionValue: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnTypeToTableID2(var TableID: Integer; Type: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckDimValueAllowed(DimVal: Record "Dimension Value"; var DimValueAllowed: Boolean; var DimErr: Text[250])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckICDimValueAllowed(ICDimVal: Record "IC Dimension Value"; var DimValueAllowed: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnGetDefaultDimIDOnAfterAttributeGlobalDims(var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnGetDefaultDimOnBeforeCreate(var TempDimBuf: Record "Dimension Buffer" temporary; TableID: Integer; No: Code[20]; GLSetupShortcutDimCode: array[8] of Code[20]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20]; var IsHandled: Boolean; SourceCode: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnUpdateJobTaskDimOnBeforConfirm(DefaultDimension: Record "Default Dimension"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnGetDefaultDimIDOnBeforeTempDimSetEntryInsert(var DimensionSetEntry: Record "Dimension Set Entry"; var DimensionBuffer: Record "Dimension Buffer"; SourceCode: Code[20]);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterTypeToTableID1(Type: Integer; var TableId: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterSalesLineTypeToTableID(Type: Enum "Sales Line Type"; var TableId: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterPurchLineTypeToTableID(Type: Enum "Purchase Line Type"; var TableId: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterReqLineTypeToTableID(Type: Enum "Requisition Line Type"; var TableId: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterTypeToTableID4(Type: Integer; var TableId: Integer)
begin
end;
#if not CLEAN27
[Obsolete('This event is never raised.', '27.0')]
[IntegrationEvent(false, false)]
local procedure OnAfterTypeToTableID5(Type: Integer; var TableId: Integer)
begin
end;
#endif
[IntegrationEvent(false, false)]
local procedure OnBeforeGetDimensionSetID(var TempDimSetEntry: Record "Dimension Set Entry" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnEditDimensionSetOnBeforeEditDimEntries(var EditDimSetEntries: Page "Edit Dimension Set Entries")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnLookupDimValueCodeOnBeforeDimValRunModal(var DimensionValue: Record "Dimension Value"; FieldNumber: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckDimValuePostingOnBeforeLogErrors(TempDefaultDim: Record "Default Dimension" temporary; var DimSetEntry: Record "Dimension Set Entry"; var LastErrorMessage: Record "Error Message"; var ErrorMessageMgt: Codeunit "Error Message Management"; var isHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckValuePostingOnBeforeExit(TableID: array[10] of Integer; No: array[10] of Code[20]; var TempDimensionBuffer: Record "Dimension Buffer" temporary; var LastErrorMessage: Record "Error Message"; var ErrorMessageManagement: Codeunit "Error Message Management"; var IsChecked: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckValuePostingOnAfterDefaultDimLoop(var TempDimBuf: Record "Dimension Buffer" temporary; var DefaultDim: Record "Default Dimension")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckDimValuePostingOnBeforeExit(TableID: array[10] of Integer; No: array[10] of Code[20]; DimSetID: Integer; var LastErrorMessage: Record "Error Message"; var ErrorMessageManagement: Codeunit "Error Message Management"; var IsChecked: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCreateDimSetFromJobTaskDim(JobNo: Code[20]; JobTaskNo: Code[20]; var GlobalDimVal1: Code[20]; var GlobalDimVal2: Code[20]; var NewDimSetID: Integer; var IsHandled: Boolean; var DimValue: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeGetRecDefaultDimID(RecVariant: Variant; CurrFieldNo: Integer; var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; var SourceCode: Code[20]; var InheritFromDimSetID: Integer; var InheritFromTableNo: Integer; var Result: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterGetRecDefaultDimIDProcedure(RecVariant: Variant; CurrFieldNo: Integer; var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; var SourceCode: Code[20]; var InheritFromDimSetID: Integer; var InheritFromTableNo: Integer; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20]; var DefaultDimSetID: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeGetDefaultDimIDProcedure(var DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; SourceCode: Code[20]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20]; InheritFromDimSetID: Integer; InheritFromTableNo: Integer; var DimVal: Record "Dimension Value"; var Result: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnGetDefaultDimIDOnBeforeFindNewDimSetIDProcedure(var TempDimensionBuffer: Record "Dimension Buffer" temporary; DefaultDimSource: List of [Dictionary of [Integer, Code[20]]]; var GlobalDim1Code: Code[20]; var GlobalDim2Code: Code[20]; SourceCode: Code[20]; GLSetupShortcutDimCode: array[8] of Code[20]; var TempDimensionSetEntry0: Record "Dimension Set Entry" temporary; InheritFromDimSetID: Integer; InheritFromTableNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnGetDefaultDimIDOnBeforeGetInheritDimensionSet(var TempDimensionSetEntry0: Record "Dimension Set Entry" temporary; var InheritFromDimSetID: Integer; var InheritFromTableNo: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(true, false)]
local procedure OnAfterUseShortcutDims(var DimVisible1: Boolean; var DimVisible2: Boolean; var DimVisible3: Boolean; var DimVisible4: Boolean; var DimVisible5: Boolean; var DimVisible6: Boolean; var DimVisible7: Boolean; var DimVisible8: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyJobTaskDimToJobTaskDim(JobNo: Code[20]; JobTaskNo: Code[20]; NewJobNo: Code[20]; NewJobTaskNo: Code[20]; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckDimValueCombOnBeforeLogError(Dim1: Code[20]; Dim1Value: Code[20]; Dim2: Code[20]; Dim2Value: Code[20]; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckDimValueOnBeforeCheckDimValBlocked(DimCode: Code[20]; DimValCode: Code[20]; var Result: Boolean; var IsHandled: Boolean; var DimensionValue: Record "Dimension Value")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterSetSourceCode(var SourceCodeSetup: Record "Source Code Setup"; TableID: Integer; var SourceCode: Code[10]);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAllowedDimensionValueConfirm(var DimensionValue: Record "Dimension Value"; var DefaultDimension: Record "Default Dimension"; var Confirmed: Boolean; var ConfirmHandled: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterEditDimensionSet(var DimSetID: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterDefaultDimObjectNoList(var TempAllObjWithCaption: Record AllObjWithCaption temporary)
begin
end;
}