Codeunit 408 DimensionManagement

Base Application, Microsoft.Finance.Dimension

src/Layers/W1/BaseApp/Finance/Dimension/DimensionManagement.Codeunit.al4,171 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;}