Table 349 Dimension Value

Base Application, Microsoft.Finance.Dimension

src/Layers/W1/BaseApp/Finance/Dimension/DimensionValue.Table.al837 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>/// Table Dimension Value (ID 349)./// This table stores the individual values that can be assigned to dimensions./// Dimension values represent the actual categories or items within a dimension that can be used for analysis./// Supports hierarchical structures with heading, total, and begin/end-total types for reporting purposes./// </summary>namespace Microsoft.Finance.Dimension;using Microsoft.CostAccounting.Setup;using Microsoft.Finance.Analysis;using Microsoft.Finance.Consolidation;using Microsoft.Finance.GeneralLedger.Budget;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Intercompany.Dimension;using Microsoft.Inventory.Analysis;/// <summary>/// Table Dimension Value (ID 349)./// Stores the individual values that can be assigned to dimensions for transaction analysis./// Provides hierarchical organization with different value types for flexible reporting structures./// </summary>table 349 "Dimension Value"{    Caption = 'Dimension Value';    LookupPageID = "Dimension Value List";    DataClassification = CustomerContent;    fields    {        /// <summary>        /// The dimension code that this value belongs to.        /// Links this dimension value to its parent dimension definition.        /// </summary>        field(1; "Dimension Code"; Code[20])        {            Caption = 'Dimension Code';            ToolTip = 'Specifies the dimension code for the dimension value.';            NotBlank = true;            TableRelation = Dimension;            trigger OnValidate()            begin                UpdateMapToICDimensionCode();            end;        }        /// <summary>        /// The unique code that identifies this dimension value within its dimension.        /// This code is used in transactions to specify the dimension analysis category.        /// </summary>        field(2; "Code"; Code[20])        {            Caption = 'Code';            ToolTip = 'Specifies the code for the dimension value.';            OptimizeForTextSearch = true;            NotBlank = true;            trigger OnValidate()            begin                if UpperCase(Code) = Text002 then                    Error(Text003,                      FieldCaption(Code));            end;        }        /// <summary>        /// The descriptive name of the dimension value that appears in the user interface.        /// Provides a user-friendly description of what this dimension value represents.        /// </summary>        field(3; Name; Text[50])        {            Caption = 'Name';            ToolTip = 'Specifies a descriptive name for the dimension value.';            OptimizeForTextSearch = true;        }        /// <summary>        /// Defines the type of dimension value for reporting hierarchy purposes.        /// Standard values can be posted to, while Heading, Total, Begin-Total, and End-Total are used for reporting structure.        /// </summary>        field(4; "Dimension Value Type"; Option)        {            Caption = 'Dimension Value Type';            ToolTip = 'Specifies the purpose of the dimension value.';            OptionCaption = 'Standard,Heading,Total,Begin-Total,End-Total';            OptionMembers = Standard,Heading,Total,"Begin-Total","End-Total";            trigger OnValidate()            begin                if ("Dimension Value Type" <> "Dimension Value Type"::Standard) and                   (xRec."Dimension Value Type" = xRec."Dimension Value Type"::Standard)                then                    if CheckIfDimValueUsed() then                        Error(Text004, GetCheckDimErr());                Totaling := '';            end;        }        /// <summary>        /// Filter specification for Total and End-Total dimension value types.        /// Defines which dimension values are included in the total calculation for reporting.        /// </summary>        field(5; Totaling; Text[250])        {            Caption = 'Totaling';            ToolTip = 'Specifies an account interval or a list of account numbers. The entries of the account will be totaled to give a total balance. How entries are totaled depends on the value in the Account Type field.';            OptimizeForTextSearch = true;            TableRelation = if ("Dimension Value Type" = const(Total)) "Dimension Value"."Dimension Code" where("Dimension Code" = field("Dimension Code"));            ValidateTableRelation = false;            trigger OnValidate()            begin                if not ("Dimension Value Type" in                        ["Dimension Value Type"::Total, "Dimension Value Type"::"End-Total"]) and (Totaling <> '')                then                    FieldError("Dimension Value Type");            end;        }        /// <summary>        /// Indicates whether the dimension value is blocked from being used in new transactions.        /// Blocked dimension values cannot be selected in new documents but existing data remains unchanged.        /// </summary>        field(6; Blocked; Boolean)        {            Caption = 'Blocked';            ToolTip = 'Specifies that the related record is blocked from being posted in transactions, for example a customer that is declared insolvent or an item that is placed in quarantine.';        }        /// <summary>        /// The consolidation code used when consolidating financial data across business units.        /// Links this dimension value to corresponding dimension values in subsidiary companies.        /// </summary>        field(7; "Consolidation Code"; Code[20])        {            AccessByPermission = TableData "Business Unit" = R;            Caption = 'Consolidation Code';            ToolTip = 'Specifies the code that is used for consolidation.';        }        /// <summary>        /// Controls the visual indentation level for hierarchical display in reports and forms.        /// Used to create structured layouts with heading and total dimension values.        /// </summary>        field(8; Indentation; Integer)        {            Caption = 'Indentation';        }        /// <summary>        /// Identifies which global dimension position this dimension value belongs to.        /// Values 1-8 correspond to Global Dimension 1, Global Dimension 2, and Shortcut Dimensions 3-8.        /// </summary>        field(9; "Global Dimension No."; Integer)        {            Caption = 'Global Dimension No.';        }        /// <summary>        /// Maps this dimension value to an intercompany dimension for transactions between related companies.        /// Must correspond to a valid IC dimension in the intercompany setup.        /// </summary>        field(10; "Map-to IC Dimension Code"; Code[20])        {            Caption = 'Map-to IC Dimension Code';            ToolTip = 'Specifies the intercompany''s dimension code associated with the dimension of the current company.';            trigger OnValidate()            begin                if "Map-to IC Dimension Code" <> xRec."Map-to IC Dimension Code" then                    Validate("Map-to IC Dimension Value Code", '');            end;        }        /// <summary>        /// Maps this dimension value to a specific intercompany dimension value code.        /// Used for automatic translation during intercompany transactions.        /// </summary>        field(11; "Map-to IC Dimension Value Code"; Code[20])        {            Caption = 'Map-to IC Dimension Value Code';            ToolTip = 'Specifies which intercompany dimension value corresponds to the dimension value on the line.';            TableRelation = "IC Dimension Value".Code where("Dimension Code" = field("Map-to IC Dimension Code"));        }        /// <summary>        /// Unique system-generated identifier for the dimension value.        /// Used internally for performance optimization in dimension set operations.        /// </summary>        field(12; "Dimension Value ID"; Integer)        {            AutoIncrement = true;            Caption = 'Dimension Value ID';            Editable = false;            trigger OnValidate()            begin                Error(Text006, FieldCaption("Dimension Value ID"));            end;        }        /// <summary>        /// System field that tracks when the dimension value record was last modified.        /// Used for synchronization and audit purposes.        /// </summary>        field(8001; "Last Modified Date Time"; DateTime)        {            Caption = 'Last Modified Date Time';        }        /// <summary>        /// System identifier linking this dimension value to its parent dimension record.        /// Used for API integration and maintaining referential integrity.        /// </summary>        field(8002; "Dimension Id"; Guid)        {            Caption = 'Dimension Id';            TableRelation = Dimension.SystemId;            trigger OnValidate()            var                Dimension: Record Dimension;            begin                if Dimension.GetBySystemId("Dimension Id") then                    Validate("Dimension Code", Dimension.Code);            end;        }    }    keys    {        key(Key1; "Dimension Code", "Code")        {            Clustered = true;        }        key(Key2; "Code", "Global Dimension No.")        {        }        key(Key3; Name)        {        }    }    fieldgroups    {        fieldgroup(DropDown; "Code", Name)        {        }    }    trigger OnDelete()    var        DimValuePerAccount: Record "Dim. Value per Account";    begin        CheckIfDimValueUsedFromOnDelete();        DimValueComb.SetRange("Dimension 1 Code", "Dimension Code");        DimValueComb.SetRange("Dimension 1 Value Code", Code);        DimValueComb.DeleteAll(true);        DimValueComb.Reset();        DimValueComb.SetRange("Dimension 2 Code", "Dimension Code");        DimValueComb.SetRange("Dimension 2 Value Code", Code);        DimValueComb.DeleteAll(true);        DefaultDim.SetRange("Dimension Code", "Dimension Code");        DefaultDim.SetRange("Dimension Value Code", Code);        DefaultDim.DeleteAll(true);        SelectedDim.SetRange("Dimension Code", "Dimension Code");        SelectedDim.SetRange("New Dimension Value Code", Code);        SelectedDim.DeleteAll(true);        AnalysisSelectedDim.SetRange("Dimension Code", "Dimension Code");        AnalysisSelectedDim.SetRange("New Dimension Value Code", Code);        AnalysisSelectedDim.DeleteAll(true);        DimValuePerAccount.SetRange("Dimension Code", "Dimension Code");        DimValuePerAccount.SetRange("Dimension Value Code", Code);        DimValuePerAccount.DeleteAll(true);        RemoveICDimensionValueMappings();        DimMgt.UpdateDefaultDimensionAllowedDimensionValues(Rec);    end;    trigger OnInsert()    begin        TestField("Dimension Code");        TestField(Code);        "Global Dimension No." := GetGlobalDimensionNo();        UpdateCostAccFromDim(Rec, Rec, 0);        DimMgt.AddDefaultDimensionAllowedDimensionValue(Rec);        SetLastModifiedDateTime();    end;    trigger OnModify()    begin        if "Dimension Code" <> xRec."Dimension Code" then            "Global Dimension No." := GetGlobalDimensionNo();        UpdateCostAccFromDim(Rec, xRec, 1);        SetLastModifiedDateTime();    end;    trigger OnRename()    var        DimValuePerAccount: Record "Dim. Value per Account";    begin        OnBeforeOnRename(Rec, xRec);        if (xRec."Dimension Code" <> '') and ("Dimension Code" <> xRec."Dimension Code") then            Error(Text006, FieldCaption("Dimension Code"));        RenameBudgEntryDim();        RenameAnalysisViewEntryDim();        RenameItemBudgEntryDim();        RenameItemAnalysisViewEntryDim();        UpdateCostAccFromDim(Rec, xRec, 3);        DimValuePerAccount.RenameDimensionValue("Dimension Code", xRec.Code, Code);        SetLastModifiedDateTime();    end;    var        DimSetEntry: Record "Dimension Set Entry";        DimValueComb: Record "Dimension Value Combination";        DefaultDim: Record "Default Dimension";        SelectedDim: Record "Selected Dimension";        AnalysisSelectedDim: Record "Analysis Selected Dimension";        CostAccSetup: Record "Cost Accounting Setup";        CostAccMgt: Codeunit "Cost Account Mgt";        DimMgt: Codeunit DimensionManagement;#pragma warning disable AA0074#pragma warning disable AA0470        Text000: Label '%1\You cannot delete it.';#pragma warning restore AA0470        Text002: Label '(CONFLICT)';#pragma warning disable AA0470        Text003: Label '%1 can not be (CONFLICT). This name is used internally by the system.';        Text004: Label '%1\You cannot change the type.';#pragma warning restore AA0470        Text005: Label 'This dimension value has been used in posted or budget entries and is included in a dimension set.';#pragma warning disable AA0470        Text006: Label 'You cannot change the value of %1.';#pragma warning restore AA0470#pragma warning restore AA0074    /// <summary>    /// Checks whether this dimension value is being used in posted entries or dimension sets.    /// Prevents deletion or modification of dimension values that would cause data integrity issues.    /// </summary>    /// <returns>True if the dimension value is used in the system; false otherwise.</returns>    procedure CheckIfDimValueUsed() Result: Boolean    begin        DimSetEntry.SetCurrentKey("Dimension Value ID");        DimSetEntry.SetRange("Dimension Value ID", "Dimension Value ID");        Result := not DimSetEntry.IsEmpty();        OnAfterCheckIfDimValueUsed(Rec, DimSetEntry, Result);    end;    local procedure UpdateCostAccFromDim(var DimensionValue: Record "Dimension Value"; var xDimensionValue: Record "Dimension Value"; CallingTrigger: Option OnInsert,OnModify,,OnRename)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateCostAccFromDim(DimensionValue, xDimensionValue, CallingTrigger, IsHandled);        if IsHandled then            exit;        if CostAccSetup.Get() then begin            CostAccMgt.UpdateCostCenterFromDim(DimensionValue, xDimensionValue, CallingTrigger);            CostAccMgt.UpdateCostObjectFromDim(DimensionValue, xDimensionValue, CallingTrigger);        end;    end;    local procedure GetCheckDimErr(): Text[250]    begin        exit(Text005);    end;    local procedure CheckIfDimValueUsedFromOnDelete()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckIfDimValueUsedFromOnDelete(Rec, xRec, IsHandled);        if IsHandled then            exit;        if CheckIfDimValueUsed() then            Error(Text000, GetCheckDimErr());    end;    local procedure RenameBudgEntryDim()    var        GLBudget: Record "G/L Budget Name";        GLBudgetEntry: Record "G/L Budget Entry";        GLBudgetEntry2: Record "G/L Budget Entry";        BudgDimNo: Integer;    begin        GLBudget.LockTable();        if GLBudget.Find('-') then            repeat            until GLBudget.Next() = 0;        for BudgDimNo := 1 to 4 do begin            case true of                BudgDimNo = 1:                    GLBudget.SetRange("Budget Dimension 1 Code", "Dimension Code");                BudgDimNo = 2:                    GLBudget.SetRange("Budget Dimension 2 Code", "Dimension Code");                BudgDimNo = 3:                    GLBudget.SetRange("Budget Dimension 3 Code", "Dimension Code");                BudgDimNo = 4:                    GLBudget.SetRange("Budget Dimension 4 Code", "Dimension Code");            end;            if GLBudget.Find('-') then begin                GLBudgetEntry.SetCurrentKey("Budget Name", "G/L Account No.", "Business Unit Code", "Global Dimension 1 Code");                repeat                    GLBudgetEntry.SetRange("Budget Name", GLBudget.Name);                    case true of                        BudgDimNo = 1:                            GLBudgetEntry.SetRange("Budget Dimension 1 Code", xRec.Code);                        BudgDimNo = 2:                            GLBudgetEntry.SetRange("Budget Dimension 2 Code", xRec.Code);                        BudgDimNo = 3:                            GLBudgetEntry.SetRange("Budget Dimension 3 Code", xRec.Code);                        BudgDimNo = 4:                            GLBudgetEntry.SetRange("Budget Dimension 4 Code", xRec.Code);                    end;                    if GLBudgetEntry.Find('-') then                        repeat                            GLBudgetEntry2 := GLBudgetEntry;                            case true of                                BudgDimNo = 1:                                    GLBudgetEntry2."Budget Dimension 1 Code" := Code;                                BudgDimNo = 2:                                    GLBudgetEntry2."Budget Dimension 2 Code" := Code;                                BudgDimNo = 3:                                    GLBudgetEntry2."Budget Dimension 3 Code" := Code;                                BudgDimNo = 4:                                    GLBudgetEntry2."Budget Dimension 4 Code" := Code;                            end;                            GLBudgetEntry2.Modify();                        until GLBudgetEntry.Next() = 0;                    GLBudgetEntry.Reset();                until GLBudget.Next() = 0;            end;            GLBudget.Reset();        end;    end;    local procedure RenameAnalysisViewEntryDim()    var        AnalysisView: Record "Analysis View";        AnalysisViewEntry: Record "Analysis View Entry";        AnalysisViewEntry2: Record "Analysis View Entry";        AnalysisViewBudgEntry: Record "Analysis View Budget Entry";        AnalysisViewBudgEntry2: Record "Analysis View Budget Entry";        DimensionNo: Integer;    begin        AnalysisView.LockTable();        if AnalysisView.Find('-') then            repeat            until AnalysisView.Next() = 0;        for DimensionNo := 1 to 4 do begin            case true of                DimensionNo = 1:                    AnalysisView.SetRange("Dimension 1 Code", "Dimension Code");                DimensionNo = 2:                    AnalysisView.SetRange("Dimension 2 Code", "Dimension Code");                DimensionNo = 3:                    AnalysisView.SetRange("Dimension 3 Code", "Dimension Code");                DimensionNo = 4:                    AnalysisView.SetRange("Dimension 4 Code", "Dimension Code");            end;            if AnalysisView.Find('-') then                repeat                    AnalysisViewEntry.SetRange("Analysis View Code", AnalysisView.Code);                    AnalysisViewBudgEntry.SetRange("Analysis View Code", AnalysisView.Code);                    case true of                        DimensionNo = 1:                            begin                                AnalysisViewEntry.SetRange("Dimension 1 Value Code", xRec.Code);                                AnalysisViewBudgEntry.SetRange("Dimension 1 Value Code", xRec.Code);                            end;                        DimensionNo = 2:                            begin                                AnalysisViewEntry.SetRange("Dimension 2 Value Code", xRec.Code);                                AnalysisViewBudgEntry.SetRange("Dimension 2 Value Code", xRec.Code);                            end;                        DimensionNo = 3:                            begin                                AnalysisViewEntry.SetRange("Dimension 3 Value Code", xRec.Code);                                AnalysisViewBudgEntry.SetRange("Dimension 3 Value Code", xRec.Code);                            end;                        DimensionNo = 4:                            begin                                AnalysisViewEntry.SetRange("Dimension 4 Value Code", xRec.Code);                                AnalysisViewBudgEntry.SetRange("Dimension 4 Value Code", xRec.Code);                            end;                    end;                    if AnalysisViewEntry.Find('-') then                        repeat                            AnalysisViewEntry2 := AnalysisViewEntry;                            case true of                                DimensionNo = 1:                                    AnalysisViewEntry2."Dimension 1 Value Code" := Code;                                DimensionNo = 2:                                    AnalysisViewEntry2."Dimension 2 Value Code" := Code;                                DimensionNo = 3:                                    AnalysisViewEntry2."Dimension 3 Value Code" := Code;                                DimensionNo = 4:                                    AnalysisViewEntry2."Dimension 4 Value Code" := Code;                            end;                            AnalysisViewEntry.Delete();                            AnalysisViewEntry2.Insert();                        until AnalysisViewEntry.Next() = 0;                    AnalysisViewEntry.Reset();                    if AnalysisViewBudgEntry.Find('-') then                        repeat                            AnalysisViewBudgEntry2 := AnalysisViewBudgEntry;                            case true of                                DimensionNo = 1:                                    AnalysisViewBudgEntry2."Dimension 1 Value Code" := Code;                                DimensionNo = 2:                                    AnalysisViewBudgEntry2."Dimension 2 Value Code" := Code;                                DimensionNo = 3:                                    AnalysisViewBudgEntry2."Dimension 3 Value Code" := Code;                                DimensionNo = 4:                                    AnalysisViewBudgEntry2."Dimension 4 Value Code" := Code;                            end;                            AnalysisViewBudgEntry.Delete();                            AnalysisViewBudgEntry2.Insert();                        until AnalysisViewBudgEntry.Next() = 0;                    AnalysisViewBudgEntry.Reset();                until AnalysisView.Next() = 0;            AnalysisView.Reset();        end;    end;    local procedure RenameItemBudgEntryDim()    var        ItemBudget: Record "Item Budget Name";        ItemBudgetEntry: Record "Item Budget Entry";        ItemBudgetEntry2: Record "Item Budget Entry";        BudgDimNo: Integer;    begin        ItemBudget.LockTable();        if ItemBudget.Find('-') then            repeat            until ItemBudget.Next() = 0;        for BudgDimNo := 1 to 3 do begin            case true of                BudgDimNo = 1:                    ItemBudget.SetRange("Budget Dimension 1 Code", "Dimension Code");                BudgDimNo = 2:                    ItemBudget.SetRange("Budget Dimension 2 Code", "Dimension Code");                BudgDimNo = 3:                    ItemBudget.SetRange("Budget Dimension 3 Code", "Dimension Code");            end;            if ItemBudget.Find('-') then begin                ItemBudgetEntry.SetCurrentKey(                  "Analysis Area", "Budget Name", "Item No.", "Source Type", "Source No.", Date, "Location Code", "Global Dimension 1 Code");                repeat                    ItemBudgetEntry.SetRange("Analysis Area", ItemBudget."Analysis Area");                    ItemBudgetEntry.SetRange("Budget Name", ItemBudget.Name);                    case true of                        BudgDimNo = 1:                            ItemBudgetEntry.SetRange("Budget Dimension 1 Code", xRec.Code);                        BudgDimNo = 2:                            ItemBudgetEntry.SetRange("Budget Dimension 2 Code", xRec.Code);                        BudgDimNo = 3:                            ItemBudgetEntry.SetRange("Budget Dimension 3 Code", xRec.Code);                    end;                    if ItemBudgetEntry.Find('-') then                        repeat                            ItemBudgetEntry2 := ItemBudgetEntry;                            case true of                                BudgDimNo = 1:                                    ItemBudgetEntry2."Budget Dimension 1 Code" := Code;                                BudgDimNo = 2:                                    ItemBudgetEntry2."Budget Dimension 2 Code" := Code;                                BudgDimNo = 3:                                    ItemBudgetEntry2."Budget Dimension 3 Code" := Code;                            end;                            ItemBudgetEntry2.Modify();                        until ItemBudgetEntry.Next() = 0;                    ItemBudgetEntry.Reset();                until ItemBudget.Next() = 0;            end;            ItemBudget.Reset();        end;    end;    local procedure RenameItemAnalysisViewEntryDim()    var        ItemAnalysisView: Record "Item Analysis View";        ItemAnalysisViewEntry: Record "Item Analysis View Entry";        ItemAnalysisViewEntry2: Record "Item Analysis View Entry";        ItemAnalysisViewBudgEntry: Record "Item Analysis View Budg. Entry";        ItemAnalysisViewBudgEntry2: Record "Item Analysis View Budg. Entry";        DimensionNo: Integer;    begin        ItemAnalysisView.LockTable();        if ItemAnalysisView.Find('-') then            repeat            until ItemAnalysisView.Next() = 0;        for DimensionNo := 1 to 3 do begin            case true of                DimensionNo = 1:                    ItemAnalysisView.SetRange("Dimension 1 Code", "Dimension Code");                DimensionNo = 2:                    ItemAnalysisView.SetRange("Dimension 2 Code", "Dimension Code");                DimensionNo = 3:                    ItemAnalysisView.SetRange("Dimension 3 Code", "Dimension Code");            end;            if ItemAnalysisView.Find('-') then                repeat                    ItemAnalysisViewEntry.SetRange("Analysis Area", ItemAnalysisView."Analysis Area");                    ItemAnalysisViewEntry.SetRange("Analysis View Code", ItemAnalysisView.Code);                    ItemAnalysisViewBudgEntry.SetRange("Analysis Area", ItemAnalysisView."Analysis Area");                    ItemAnalysisViewBudgEntry.SetRange("Analysis View Code", ItemAnalysisView.Code);                    case true of                        DimensionNo = 1:                            begin                                ItemAnalysisViewEntry.SetRange("Dimension 1 Value Code", xRec.Code);                                ItemAnalysisViewBudgEntry.SetRange("Dimension 1 Value Code", xRec.Code);                            end;                        DimensionNo = 2:                            begin                                ItemAnalysisViewEntry.SetRange("Dimension 2 Value Code", xRec.Code);                                ItemAnalysisViewBudgEntry.SetRange("Dimension 2 Value Code", xRec.Code);                            end;                        DimensionNo = 3:                            begin                                ItemAnalysisViewEntry.SetRange("Dimension 3 Value Code", xRec.Code);                                ItemAnalysisViewBudgEntry.SetRange("Dimension 3 Value Code", xRec.Code);                            end;                    end;                    if ItemAnalysisViewEntry.Find('-') then                        repeat                            ItemAnalysisViewEntry2 := ItemAnalysisViewEntry;                            case true of                                DimensionNo = 1:                                    ItemAnalysisViewEntry2."Dimension 1 Value Code" := Code;                                DimensionNo = 2:                                    ItemAnalysisViewEntry2."Dimension 2 Value Code" := Code;                                DimensionNo = 3:                                    ItemAnalysisViewEntry2."Dimension 3 Value Code" := Code;                            end;                            ItemAnalysisViewEntry.Delete();                            ItemAnalysisViewEntry2.Insert();                        until ItemAnalysisViewEntry.Next() = 0;                    ItemAnalysisViewEntry.Reset();                    if ItemAnalysisViewBudgEntry.Find('-') then                        repeat                            ItemAnalysisViewBudgEntry2 := ItemAnalysisViewBudgEntry;                            case true of                                DimensionNo = 1:                                    ItemAnalysisViewBudgEntry2."Dimension 1 Value Code" := Code;                                DimensionNo = 2:                                    ItemAnalysisViewBudgEntry2."Dimension 2 Value Code" := Code;                                DimensionNo = 3:                                    ItemAnalysisViewBudgEntry2."Dimension 3 Value Code" := Code;                            end;                            ItemAnalysisViewBudgEntry.Delete();                            ItemAnalysisViewBudgEntry2.Insert();                        until ItemAnalysisViewBudgEntry.Next() = 0;                    ItemAnalysisViewBudgEntry.Reset();                until ItemAnalysisView.Next() = 0;            ItemAnalysisView.Reset();        end;    end;    /// <summary>    /// Opens a lookup page for dimension values and returns a filter string of selected values.    /// Used in filter fields to allow multi-selection of dimension values.    /// </summary>    /// <param name="Dim">The dimension code to filter dimension values by.</param>    /// <param name="Text">Returns the filter string of selected dimension values.</param>    /// <returns>True if values were selected; false if cancelled.</returns>    procedure LookUpDimFilter(Dim: Code[20]; var Text: Text): Boolean    var        DimVal: Record "Dimension Value";        DimValList: Page "Dimension Value List";    begin        if Dim = '' then            exit(false);        DimValList.LookupMode(true);        DimVal.SetRange("Dimension Code", Dim);        DimValList.SetTableView(DimVal);        if DimValList.RunModal() = ACTION::LookupOK then begin            Text := DimValList.GetSelectionFilter();            exit(true);        end;        exit(false)    end;    /// <summary>    /// Opens a lookup page for selecting a single dimension value.    /// Used for dimension value selection in forms and fields.    /// </summary>    /// <param name="DimCode">The dimension code to filter dimension values by.</param>    /// <param name="DimValueCode">The current dimension value code, returns the selected value.</param>    procedure LookupDimValue(DimCode: Code[20]; var DimValueCode: Code[20])    var        DimValue: Record "Dimension Value";        DimValuesList: Page "Dimension Values";    begin        DimValue.SetRange("Dimension Code", DimCode);        DimValuesList.LookupMode := true;        DimValuesList.SetTableView(DimValue);        if DimValue.Get(DimCode, DimValueCode) then            DimValuesList.SetRecord(DimValue);        if DimValuesList.RunModal() = ACTION::LookupOK then begin            DimValuesList.GetRecord(DimValue);            DimValueCode := DimValue.Code;        end;    end;    local procedure GetGlobalDimensionNo(): Integer    var        GeneralLedgerSetup: Record "General Ledger Setup";        GlobalDimensionNo: Integer;    begin        GeneralLedgerSetup.Get();        case "Dimension Code" of            GeneralLedgerSetup."Global Dimension 1 Code":                exit(1);            GeneralLedgerSetup."Global Dimension 2 Code":                exit(2);            GeneralLedgerSetup."Shortcut Dimension 3 Code":                exit(3);            GeneralLedgerSetup."Shortcut Dimension 4 Code":                exit(4);            GeneralLedgerSetup."Shortcut Dimension 5 Code":                exit(5);            GeneralLedgerSetup."Shortcut Dimension 6 Code":                exit(6);            GeneralLedgerSetup."Shortcut Dimension 7 Code":                exit(7);            GeneralLedgerSetup."Shortcut Dimension 8 Code":                exit(8);            else begin                GlobalDimensionNo := 0;                OnGetGlobalDimensionNoOnElseCase("Dimension Code", GlobalDimensionNo);                exit(GlobalDimensionNo);            end;        end;    end;    local procedure SetLastModifiedDateTime()    begin        "Last Modified Date Time" := CurrentDateTime;    end;    local procedure UpdateMapToICDimensionCode()    var        Dimension: Record Dimension;    begin        Dimension.Get("Dimension Code");        Validate("Map-to IC Dimension Code", Dimension."Map-to IC Dimension Code");        "Dimension Id" := Dimension.SystemId;    end;    local procedure RemoveICDimensionValueMappings()    var        ICDimensionValue: Record "IC Dimension Value";    begin        ICDimensionValue.SetRange("Map-to Dimension Value Code", Rec."Code");        if not ICDimensionValue.IsEmpty() then            ICDimensionValue.ModifyAll("Map-to Dimension Value Code", '');    end;    /// <summary>    /// Integration event raised after checking if a dimension value is used in the system.    /// Allows extensions to customize the dimension value usage validation logic.    /// </summary>    /// <param name="DimensionValue">The dimension value being checked for usage.</param>    /// <param name="DimensionSetEntry">The dimension set entry used in the usage check.</param>    /// <param name="Result">Returns true if the dimension value is used; can be modified by subscribers.</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCheckIfDimValueUsed(DimensionValue: Record "Dimension Value"; DimensionSetEntry: Record "Dimension Set Entry"; var Result: Boolean)    begin    end;    /// <summary>    /// Integration event raised before checking if a dimension value is used during deletion.    /// Allows extensions to implement custom dimension value usage validation.    /// </summary>    /// <param name="DimensionValue">The dimension value being deleted.</param>    /// <param name="xDimensionValue">The original dimension value record before changes.</param>    /// <param name="IsHandled">Set to true to skip standard usage checking logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckIfDimValueUsedFromOnDelete(DimensionValue: Record "Dimension Value"; xDimensionValue: Record "Dimension Value"; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before updating cost accounting accounts from dimension value changes.    /// Allows extensions to customize cost accounting integration logic.    /// </summary>    /// <param name="DimensionValue">The dimension value being modified.</param>    /// <param name="xDimensionValue">The original dimension value record before changes.</param>    /// <param name="CallingTrigger">Indicates which trigger called this event (OnInsert, OnModify, OnRename).</param>    /// <param name="IsHandled">Set to true to skip standard cost accounting update logic.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateCostAccFromDim(var DimensionValue: Record "Dimension Value"; var xDimensionValue: Record "Dimension Value"; CallingTrigger: Option OnInsert,OnModify,,OnRename; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before renaming a dimension value.    /// Allows extensions to perform custom validation or processing before the rename operation.    /// </summary>    /// <param name="DimensionValue">The dimension value after rename with new values.</param>    /// <param name="xDimensionValue">The original dimension value record before rename.</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeOnRename(var DimensionValue: Record "Dimension Value"; var xDimensionValue: Record "Dimension Value")    begin    end;    /// <summary>    /// Integration event raised in the else case of GetGlobalDimensionNo function.    /// Allows extensions to provide global dimension numbers for custom dimension codes.    /// </summary>    /// <param name="DimensionCode">The dimension code for which the global dimension number is being requested.</param>    /// <param name="GlobalDimensionNo">Returns the global dimension number for the given dimension    /// code; set by subscribers if the dimension code is custom.</param>    [IntegrationEvent(false, false)]    local procedure OnGetGlobalDimensionNoOnElseCase(DimensionCode: Code[20]; var GlobalDimensionNo: Integer)    begin    end;}