Codeunit 2580 Dimension Correction Mgt

Base Application, Microsoft.Finance.Dimension.Correction

src/Layers/W1/BaseApp/Finance/Dimension/Correction/DimensionCorrectionMgt.Codeunit.al1,695 lines, Copyright (c) Microsoft Corporation. MIT

// ------------------------------------------------------------------------------------------------// Copyright (c) Microsoft Corporation. All rights reserved.// Licensed under the MIT License. See License.txt in the project root for license information.// ------------------------------------------------------------------------------------------------namespace Microsoft.Finance.Dimension.Correction;using Microsoft.CostAccounting.Setup;using Microsoft.Finance.Dimension;using Microsoft.Finance.GeneralLedger.Account;using Microsoft.Finance.GeneralLedger.Ledger;using System.Environment.Configuration;using System.Text;using System.Threading;using System.Utilities;/// <summary>/// Manages dimension correction operations including validation, execution, and supporting data generation./// Provides comprehensive functionality for correcting dimension errors in posted general ledger entries/// with validation, job scheduling, and status management capabilities./// </summary>codeunit 2580 "Dimension Correction Mgt"{    trigger OnRun()    begin    end;    /// <summary>    /// Validates that no blocked dimensions are used in the dimension correction changes.    /// Checks all changes to ensure dimensions and dimension values are not blocked for use.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to validate</param>    procedure ValidateNoBlockedDimensionsUsed(var DimensionCorrection: Record "Dimension Correction")    var        DimCorrectionChange: Record "Dim Correction Change";    begin        DimCorrectionChange.SetRange("Dimension Correction Entry No.", DimensionCorrection."Entry No.");        DimCorrectionChange.SetFilter("Change Type", '<>%1', DimCorrectionChange."Change Type"::"No Change");        if not DimCorrectionChange.FindSet() then            exit;        repeat            VerifyIfDimensionCanBeChanged(DimCorrectionChange);        until DimCorrectionChange.Next() = 0;    end;    /// <summary>    /// Generates supporting tables and data structures for dimension correction processing.    /// Creates target dimension set IDs and prepares temporary buffers for validation and execution.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to generate data for</param>    /// <param name="TempDimCorrectionSetBuffer">Temporary buffer to populate with correction set data</param>    procedure GenerateSupportingTables(var DimensionCorrection: Record "Dimension Correction"; var TempDimCorrectionSetBuffer: Record "Dim Correction Set Buffer" temporary)    var        DimensionCorrectionEntryLog: Record "Dim Correction Entry Log";        DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";    begin        DimCorrectSelectionCriteria.SetRange("Dimension Correction Entry No.", DimensionCorrection."Entry No.");        if DimCorrectSelectionCriteria.IsEmpty() then            Error(NoSelectionCriteriaFoundErr);        if not DimensionCorrection."Generated Set IDs" then begin            Session.LogMessage('0000EHF', StrSubstNo(StartingGenerateDimensionSetIdsLbl, DimensionCorrection."Entry No."), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', DimensionCorrectionTok);            GenerateTargetDimensionSetIds(DimensionCorrection);            Session.LogMessage('0000EHG', StrSubstNo(CompletedGenerateDimensionSetIdsLbl, DimensionCorrection."Entry No."), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', DimensionCorrectionTok);        end;        if not LoadTempDimCorrectionSetBuffer(DimensionCorrection."Entry No.", TempDimCorrectionSetBuffer) then            Error(NoChangesFoundErr);        if not DimensionCorrection."Generated Selected Entries" then begin            Session.LogMessage('0000EKA', StrSubstNo(StartingGenerateSelectedEntriesLbl, DimensionCorrection."Entry No."), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', DimensionCorrectionTok);            GenerateSelectedEntries(DimensionCorrection, TempDimCorrectionSetBuffer);            Session.LogMessage('0000EKB', StrSubstNo(CompletedGenerateSelectedEntriesLbl, DimensionCorrection."Entry No."), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', DimensionCorrectionTok);        end;        DimensionCorrectionEntryLog.SetRange("Dimension Correction Entry No.", DimensionCorrection."Entry No.");        if DimensionCorrectionEntryLog.IsEmpty() then            Error(NoLedgerEntriesFoundErr);    end;    /// <summary>    /// Verifies that the dimension correction can be validated based on its current status.    /// Checks if the dimension correction is in a valid state for validation processing.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to verify</param>    procedure VerifyCanValidateDimensionCorrection(var DimensionCorrection: Record "Dimension Correction")    begin        if not (DimensionCorrection.Status in [DimensionCorrection.Status::Completed, DimensionCorrection.Status::Draft, DimensionCorrection.Status::Failed, DimensionCorrection.Status::"Validaton in Process"]) then            Error(CannotValidateDimensionCorrectionErr, DimensionCorrection.Status);    end;    /// <summary>    /// Validates that blocked dimensions and dimension values are not used in the correction.    /// Performs validation with telemetry logging to ensure data integrity.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to validate</param>    procedure ValidateBlockedNotUsed(var DimensionCorrection: Record "Dimension Correction")    begin        Session.LogMessage('0000EHD', StrSubstNo(StartingValidateDimensionCorrectionChangesTelemetryLbl, DimensionCorrection."Entry No."), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', DimensionCorrectionTok);        ValidateNoBlockedDimensionsUsed(DimensionCorrection);        Session.LogMessage('0000EHE', StrSubstNo(CompletedValidateDimensionCorrectionChangesTelemetryLbl, DimensionCorrection."Entry No."), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', DimensionCorrectionTok);    end;    /// <summary>    /// Validates dimension sets for the correction to ensure dimension combination rules are followed.    /// Checks dimension combinations and restrictions, counting any validation errors encountered.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to validate</param>    /// <param name="TempDimCorrectionSetBuffer">Temporary buffer containing dimension sets to validate</param>    /// <param name="ErrorCount">Variable to receive the count of validation errors found</param>    procedure ValidateDimensionSets(var DimensionCorrection: Record "Dimension Correction"; var TempDimCorrectionSetBuffer: Record "Dim Correction Set Buffer" temporary; var ErrorCount: Integer)    var        DimensionManagement: Codeunit DimensionManagement;        ErrorMessageManagement: Codeunit "Error Message Management";        ErrorMessage: Text[250];    begin        if DimensionCorrection.Status = DimensionCorrection.Status::"Validaton in Process" then            DimensionManagement.SetCollectErrorsMode();        TempDimCorrectionSetBuffer.FindSet();        repeat            if not DimensionManagement.CheckDimIDComb(TempDimCorrectionSetBuffer."Target Set ID") then                if DimensionCorrection.Status <> DimensionCorrection.Status::"Validaton in Process" then begin                    Commit();                    ErrorMessageManagement.GetLastError(ErrorMessage);                    Error(ErrorMessage);                end else begin                    ErrorCount += 1;                    if ErrorCount > GetMaximumNumberOfValidationErrors() then                        UpdateValidationStatusAndThrowErrorIfFailed(DimensionCorrection, ErrorCount);                end;        until TempDimCorrectionSetBuffer.Next() = 0;    end;    /// <summary>    /// Validates dimension changes across all selected entries for a dimension correction.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to validate</param>    /// <param name="TempDimCorrectionSetBuffer">Temporary buffer containing correction set data</param>    /// <param name="ErrorCount">Returns the number of validation errors encountered</param>    procedure ValidateDimensionChanges(var DimensionCorrection: Record "Dimension Correction"; var TempDimCorrectionSetBuffer: Record "Dim Correction Set Buffer" temporary; var ErrorCount: Integer)    var        LastDimCorrectionEntryLog: Record "Dim Correction Entry Log";        DimCorrectionEntryLog: Record "Dim Correction Entry Log";        UpdateCounter: Integer;    begin        Session.LogMessage('0000EK5', StrSubstNo(StartingValidateDimensionChangesForEntriesLbl, DimensionCorrection."Entry No."), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', DimensionCorrectionTok);        ErrorCount := 0;        UpdateCounter := 0;        if DimensionCorrection."Last Validated Entry No." > 0 then begin            LastDimCorrectionEntryLog.SetRange("Dimension Correction Entry No.", DimensionCorrection."Entry No.");            LastDimCorrectionEntryLog.SetFilter("Start Entry No.", '<=%1', DimensionCorrection."Last Validated Entry No.");            LastDimCorrectionEntryLog.SetFilter("End Entry No.", '>%1', DimensionCorrection."Last Validated Entry No.");            if LastDimCorrectionEntryLog.FindFirst() then                ValidateDimensionChanges(DimensionCorrection."Last Validated Entry No." + 1, LastDimCorrectionEntryLog."End Entry No.", UpdateCounter, TempDimCorrectionSetBuffer, DimensionCorrection, ErrorCount);        end;        DimCorrectionEntryLog.SetRange("Dimension Correction Entry No.", DimensionCorrection."Entry No.");        DimCorrectionEntryLog.SetFilter("Start Entry No.", '>=%1', DimensionCorrection."Last Validated Entry No.");        DimCorrectionEntryLog.SetCurrentKey("Start Entry No.");        DimCorrectionEntryLog.Ascending(true);        if DimCorrectionEntryLog.FindSet() then            repeat                ValidateDimensionChanges(DimCorrectionEntryLog."Start Entry No.", DimCorrectionEntryLog."End Entry No.", UpdateCounter, TempDimCorrectionSetBuffer, DimensionCorrection, ErrorCount);            until DimCorrectionEntryLog.Next() = 0;        DimensionCorrection."Validated Selected Entries" := true;        DimensionCorrection.Modify();        Commit();        Session.LogMessage('0000EK6', StrSubstNo(CompletedValidateDimensionChangesForEntriesLbl, DimensionCorrection."Entry No."), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', DimensionCorrectionTok);    end;    local procedure ValidateDimensionChanges(StartEntryNo: Integer; EndEntryNo: Integer; var UpdateCounter: Integer; var TempDimCorrectionSetBuffer: Record "Dim Correction Set Buffer" temporary; var DimensionCorrection: Record "Dimension Correction"; var ErrorCount: Integer)    var        GLEntry: Record "G/L Entry";        DimensionManagement: Codeunit DimensionManagement;        StartDateTime: DateTime;        TableID: array[10] of Integer;        No: array[10] of Code[20];    begin        StartDateTime := CurrentDateTime();        GLEntry.SetFilter("Entry No.", '>=%1&<=%2', StartEntryNo, EndEntryNo);        GLEntry.SetLoadFields("Entry No.", "Dimension Set ID", "G/L Account No.");        if GLEntry.IsEmpty() then            exit;        if DimensionCorrection.Status = DimensionCorrection.Status::"Validaton in Process" then            DimensionManagement.SetCollectErrorsMode();        GLEntry.FindSet();        repeat            UpdateCounter += 1;            No[1] := GLEntry."G/L Account No.";            TableID[1] := Database::"G/L Account";            TempDimCorrectionSetBuffer.Get(DimensionCorrection."Entry No.", GLEntry."Dimension Set ID");            if not DimensionManagement.CheckDimValuePosting(TableID, No, TempDimCorrectionSetBuffer."Target Set ID") then                if DimensionCorrection.Status <> DimensionCorrection.Status::"Validaton in Process" then begin                    DimensionCorrection."Last Validated Entry No." := GLEntry."Entry No.";                    DimensionCorrection.Modify();                    Commit();                    Error(InvalidDimensionCorrectionErr, GLEntry."Entry No.", DimensionManagement.GetDimValuePostingErr());                end else begin                    ErrorCount += 1;                    if ErrorCount > GetMaximumNumberOfValidationErrors() then                        UpdateValidationStatusAndThrowErrorIfFailed(DimensionCorrection, ErrorCount);                end;            if UpdateCounter >= GetCommitCount() then begin                UpdateCounter := 0;                DimensionCorrection."Last Validated Entry No." := GLEntry."Entry No.";                DimensionCorrection.Modify();                Commit();                Session.LogMessage('0000EK7', StrSubstNo(CommitedValidateGLEntriesLbl, DimensionCorrection."Entry No.", Format(CurrentDateTime() - StartDateTime), GetCommitCount()), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', DimensionCorrectionTok);                StartDateTime := CurrentDateTime();            end;        until GLEntry.Next() = 0;        if UpdateCounter > 0 then begin            DimensionCorrection."Last Validated Entry No." := GLEntry."Entry No.";            DimensionCorrection.Modify();            Commit();        end;    end;    /// <summary>    /// Verifies whether a specific dimension can be changed based on blocking setup.    /// </summary>    /// <param name="DimCorrectionChange">Dimension correction change record to verify</param>    procedure VerifyIfDimensionCanBeChanged(var DimCorrectionChange: Record "Dim Correction Change")    var        DimCorrecitonBlocked: Record "Dim Correction Blocked Setup";    begin        if DimCorrecitonBlocked.Get(DimCorrectionChange."Dimension Code") then            Error(CannotChangeDimensionCodeBlockedErr, DimCorrectionChange."Dimension Code");        OnAfterVerifyIfDimensionCanBeChanged(DimCorrectionChange);    end;    /// <summary>    /// Deletes all validation error messages associated with a dimension correction.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to delete validation errors for</param>    procedure DeleteValidationErrors(var DimensionCorrection: Record "Dimension Correction")    var        ErrorMessage: Record "Error Message";    begin        if not IsNullGuid(DimensionCorrection."Validation Errors Register ID") then begin            ErrorMessage.SetRange("Register ID", DimensionCorrection."Validation Errors Register ID");            ErrorMessage.DeleteAll();        end;        Clear(DimensionCorrection."Validation Errors Register ID");    end;    /// <summary>    /// Updates validation status and throws an error if validation failed.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to update status for</param>    /// <param name="ErrorCount">Number of validation errors encountered</param>    procedure UpdateValidationStatusAndThrowErrorIfFailed(var DimensionCorrection: Record "Dimension Correction"; ErrorCount: Integer)    begin        DimensionCorrection."Validated At" := CurrentDateTime();        DimensionCorrection."Validated Selected Entries" := ErrorCount = 0;        DimensionCorrection.Modify();        if ErrorCount > 0 then begin            DimensionCorrection.SetValidateDimensionChangesText(GetValidationStatusText(DimensionCorrection, StrSubstNo(ValidationFailedErr, ErrorCount)));            DimensionCorrection.Modify();            Commit();            Error(ValidationFailedErr, ErrorCount);        end else begin            DimensionCorrection.SetValidateDimensionChangesText(GetValidationStatusText(DimensionCorrection, ''));            DimensionCorrection.Modify();            Commit();        end;    end;    /// <summary>    /// Generates selected entries for dimension correction based on selection criteria.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to generate entries for</param>    /// <param name="TempDimCorrectionSetBuffer">Temporary buffer to store generated correction set data</param>    procedure GenerateSelectedEntries(var DimensionCorrection: Record "Dimension Correction"; var TempDimCorrectionSetBuffer: Record "Dim Correction Set Buffer" temporary)    var        DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";        TempExcludedEntriesInteger: Record Integer temporary;    begin        if not GetSelectionCriteria(DimensionCorrection."Entry No.", DimCorrectSelectionCriteria) then            exit;        LoadExcludedEntries(DimensionCorrection, TempExcludedEntriesInteger);        repeat            GenerateSelectedEntries(DimCorrectSelectionCriteria, DimensionCorrection, TempDimCorrectionSetBuffer, TempExcludedEntriesInteger);        until DimCorrectSelectionCriteria.Next() = 0;        DimensionCorrection."Generated Selected Entries" := true;        DimensionCorrection.Modify();        Commit();    end;    local procedure LoadExcludedEntries(DimensionCorrection: Record "Dimension Correction"; var TempExcludedEntriesInteger: Record Integer temporary)    var        ExlcudedDimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";        GLEntry: Record "G/L Entry";        ExcludedEntriesView: Text;    begin        ExlcudedDimCorrectSelectionCriteria.SetRange("Dimension Correction Entry No.", DimensionCorrection."Entry No.");        ExlcudedDimCorrectSelectionCriteria.SetRange("Filter Type", ExlcudedDimCorrectSelectionCriteria."Filter Type"::Excluded);        if ExlcudedDimCorrectSelectionCriteria.IsEmpty() then            exit;        ExlcudedDimCorrectSelectionCriteria.FindSet();        GLEntry.SetLoadFields("Entry No.");        repeat            ExlcudedDimCorrectSelectionCriteria.GetSelectionFilter(ExcludedEntriesView);            GLEntry.SetView(ExcludedEntriesView);            if not GLEntry.IsEmpty() then                if GLEntry.FindSet() then                    repeat                        TempExcludedEntriesInteger.Number := GLEntry."Entry No.";                        if TempExcludedEntriesInteger.Insert() then;                    until GLEntry.Next() = 0;        until ExlcudedDimCorrectSelectionCriteria.Next() = 0;    end;    local procedure GenerateSelectedEntries(var DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria"; var DimensionCorrection: Record "Dimension Correction"; var TempDimCorrectionSetBuffer: Record "Dim Correction Set Buffer" temporary; var TempExcludedEntriesInteger: Record Integer temporary)    var        TempInteger: Record Integer temporary;        GLEntry: Record "G/L Entry";        SelectionFilter: Text;        CommitCounter: Integer;    begin        DimCorrectSelectionCriteria.GetSelectionFilter(SelectionFilter);        if DimCorrectSelectionCriteria."Last Entry No." <> 0 then begin            GLEntry.FilterGroup(4);            GLEntry.SetFilter("Entry No.", '>%1', DimCorrectSelectionCriteria."Last Entry No.");            GLEntry.FilterGroup(0);        end;        GLEntry.SetView(SelectionFilter);        GLEntry.SetLoadFields("Entry No.");        if GLEntry.IsEmpty() then            exit;        GLEntry.FindSet();        TempInteger.SetCurrentKey(Number);        TempInteger.Ascending(true);        repeat            if IsGLEntryForUpdate(GLEntry, TempDimCorrectionSetBuffer, DimensionCorrection."Entry No.", TempExcludedEntriesInteger) then begin                if not TempInteger.Get(GLEntry."Entry No.") then begin                    TempInteger.Number := GLEntry."Entry No.";                    TempInteger.Insert();                end;                CommitCounter += 1;                if (CommitCounter > GetDictionarySizeLimit()) then begin                    WriteSelectedEntriesCriteriaToTables(TempInteger, DimensionCorrection);                    DimCorrectSelectionCriteria."Last Entry No." := GLEntry."Entry No.";                    TempInteger.DeleteAll();                    CommitCounter := 0;                end;            end;        until GLEntry.Next() = 0;        if (CommitCounter > 0) then begin            WriteSelectedEntriesCriteriaToTables(TempInteger, DimensionCorrection);            DimCorrectSelectionCriteria."Last Entry No." := GLEntry."Entry No.";            Commit();        end;    end;    /// <summary>    /// Determines if a G/L entry should be updated during dimension correction.    /// </summary>    /// <param name="GLEntry">G/L entry to check for update eligibility</param>    /// <param name="TempDimCorrectionSetBuffer">Temporary buffer containing correction set data</param>    /// <param name="DimensionCorrectionEntryNo">Dimension correction entry number</param>    /// <param name="TempExcludedEntriesInteger">Temporary buffer containing excluded entry numbers</param>    /// <returns>True if the G/L entry should be updated, false otherwise</returns>    procedure IsGLEntryForUpdate(var GLEntry: Record "G/L Entry"; var TempDimCorrectionSetBuffer: Record "Dim Correction Set Buffer" temporary; DimensionCorrectionEntryNo: Integer; var TempExcludedEntriesInteger: Record Integer temporary): boolean    begin        if not TempDimCorrectionSetBuffer.Get(DimensionCorrectionEntryNo, GLEntry."Dimension Set ID") then            exit(false);        if GLEntry."Dimension Set ID" = TempDimCorrectionSetBuffer."Target Set ID" then            exit(false);        if TempExcludedEntriesInteger.Get(GLEntry."Entry No.") then            exit(false);        exit(true);    end;    local procedure WriteSelectedEntriesCriteriaToTables(var TempInteger: Record Integer temporary; var DimensionCorrection: Record "Dimension Correction")    var        StartEntryNo: Integer;        LastEntryNo: Integer;        AddedEntries: Integer;    begin        TempInteger.FindSet();        StartEntryNo := TempInteger.Number;        LastEntryNo := TempInteger.Number;        repeat            if LastEntryNo + 1 < TempInteger.Number then begin                AddedEntries += UpdateDimCorrectionEntryLog(StartEntryNo, LastEntryNo, DimensionCorrection."Entry No.");                StartEntryNo := TempInteger.Number;            end;            LastEntryNo := TempInteger.Number;        until TempInteger.Next() = 0;        // Add last entry        AddedEntries += UpdateDimCorrectionEntryLog(StartEntryNo, LastEntryNo, DimensionCorrection."Entry No.");        DimensionCorrection."Total Selected Ledger Entries" += AddedEntries;        DimensionCorrection.Modify();    end;    local procedure UpdateDimCorrectionEntryLog(StartEntryNo: Integer; LastEntryNo: Integer; DimensionCorrectionEntryNo: Integer): Integer    var        PrevoiusDimCorrectionEntryLog: Record "Dim Correction Entry Log";        NextDimCorrectionEntryLog: Record "Dim Correction Entry Log";        DimCorrectionEntryLog: Record "Dim Correction Entry Log";        PreviousExists: Boolean;        NextExists: Boolean;        AddedEntries: Integer;    begin        AddedEntries := 0;        PrevoiusDimCorrectionEntryLog.SetRange("Dimension Correction Entry No.", DimensionCorrectionEntryNo);        PrevoiusDimCorrectionEntryLog.SetFilter("Start Entry No.", '<=%1', StartEntryNo);        PrevoiusDimCorrectionEntryLog.SetFilter("End Entry No.", '>=%1', StartEntryNo - 1);        PreviousExists := PrevoiusDimCorrectionEntryLog.FindFirst();        NextDimCorrectionEntryLog.SetRange("Dimension Correction Entry No.", DimensionCorrectionEntryNo);        NextDimCorrectionEntryLog.SetFilter("Start Entry No.", '<=%1', LastEntryNo + 1);        NextDimCorrectionEntryLog.SetFilter("End Entry No.", '>=%1', LastEntryNo);        NextExists := NextDimCorrectionEntryLog.FindFirst();        if PreviousExists then begin            if NextExists then begin                if (NextDimCorrectionEntryLog."Start Entry No." = PrevoiusDimCorrectionEntryLog."Start Entry No.") and (NextDimCorrectionEntryLog."End Entry No." = PrevoiusDimCorrectionEntryLog."End Entry No.") then                    exit(AddedEntries);                AddedEntries := NextDimCorrectionEntryLog."Start Entry No." - PrevoiusDimCorrectionEntryLog."End Entry No." - 1;                PrevoiusDimCorrectionEntryLog.Rename(PrevoiusDimCorrectionEntryLog."Dimension Correction Entry No.", PrevoiusDimCorrectionEntryLog."Start Entry No.", NextDimCorrectionEntryLog."End Entry No.");                NextDimCorrectionEntryLog.Delete();                exit(AddedEntries);            end;            if PrevoiusDimCorrectionEntryLog."End Entry No." >= LastEntryNo then                exit(AddedEntries);            AddedEntries := LastEntryNo - PrevoiusDimCorrectionEntryLog."End Entry No.";            PrevoiusDimCorrectionEntryLog.Rename(PrevoiusDimCorrectionEntryLog."Dimension Correction Entry No.", PrevoiusDimCorrectionEntryLog."Start Entry No.", LastEntryNo);            exit(AddedEntries);        end;        if NextExists then begin            AddedEntries := NextDimCorrectionEntryLog."Start Entry No." - StartEntryNo;            NextDimCorrectionEntryLog.Rename(NextDimCorrectionEntryLog."Dimension Correction Entry No.", StartEntryNo, NextDimCorrectionEntryLog."End Entry No.");            exit(AddedEntries)        end;        AddedEntries := LastEntryNo - StartEntryNo + 1;        DimCorrectionEntryLog."Dimension Correction Entry No." := DimensionCorrectionEntryNo;        DimCorrectionEntryLog."Start Entry No." := StartEntryNo;        DimCorrectionEntryLog."End Entry No." := LastEntryNo;        DimCorrectionEntryLog.Insert(true);        exit(AddedEntries)    end;    /// <summary>    /// Retrieves the target dimension correction set buffer for a specific G/L entry.    /// </summary>    /// <param name="TempDimCorrectionSetBuffer">Temporary buffer containing correction set data</param>    /// <param name="DimensionCorrection">Dimension correction record</param>    /// <param name="GLEntry">G/L entry to find target correction set for</param>    /// <returns>True if target correction set buffer found, false otherwise</returns>    procedure GetTargetDimCorrectionSetBuffer(var TempDimCorrectionSetBuffer: Record "Dim Correction Set Buffer" temporary; var DimensionCorrection: Record "Dimension Correction"; var GLEntry: Record "G/L Entry"): Boolean    begin        TempDimCorrectionSetBuffer.SetRange("Dimension Correction Entry No.", DimensionCorrection."Entry No.");        TempDimCorrectionSetBuffer.SetRange("Target Set ID", GLEntry."Dimension Set ID");        if not TempDimCorrectionSetBuffer.FindFirst() then            exit(false);        if not TempDimCorrectionSetBuffer."Multiple Target Set ID" then            exit(true);        repeat            if TempDimCorrectionSetBuffer.ContainsLedgerEntry(GLEntry."Entry No.") then                exit(true);        until TempDimCorrectionSetBuffer.Next() = 0;        exit(false);    end;    /// <summary>    /// Generates target dimension set IDs for dimension correction based on correction changes.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to generate target set IDs for</param>    procedure GenerateTargetDimensionSetIds(var DimensionCorrection: Record "Dimension Correction")    var        DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";        DimCorrectionSetBuffer: Record "Dim Correction Set Buffer";        SameTargetDimCorrectionSetBuffer: Record "Dim Correction Set Buffer";        TempDimCorrectionChange: Record "Dim Correction Change" temporary;        DimensionSetIDs: List of [Integer];        DimensionSetID: Integer;        NewDimensionSetID: Integer;        CommitCounter: Integer;    begin        if DimensionCorrection."Generated Set IDs" then            exit;        if not GetSelectionCriteria(DimensionCorrection."Entry No.", DimCorrectSelectionCriteria) then            exit;        if not GetDimCorrectionChanges(DimensionCorrection."Entry No.", TempDimCorrectionChange) then            exit;        DimensionCorrection."Started Correction" := true;        DimensionCorrection.Modify();        CommitCounter := 0;        repeat            DimCorrectSelectionCriteria.GetDimensionSetIds(DimensionSetIDs);            foreach DimensionSetID in DimensionSetIDs do                if not DimCorrectionSetBuffer.Get(DimensionCorrection."Entry No.", DimensionSetID) then                    if TransformDimensionSet(DimensionSetID, TempDimCorrectionChange, NewDimensionSetID) then                        if (NewDimensionSetID <> DimensionSetID) then begin                            DimCorrectionSetBuffer."Dimension Correction Entry No." := DimensionCorrection."Entry No.";                            DimCorrectionSetBuffer."Dimension Set ID" := DimensionSetID;                            DimCorrectionSetBuffer."Target Set ID" := NewDimensionSetID;                            SameTargetDimCorrectionSetBuffer.SetRange("Dimension Correction Entry No.", DimensionCorrection."Entry No.");                            SameTargetDimCorrectionSetBuffer.SetRange("Target Set ID", DimCorrectionSetBuffer."Target Set ID");                            if SameTargetDimCorrectionSetBuffer.FindFirst() then begin                                DimCorrectionSetBuffer."Multiple Target Set ID" := true;                                if SameTargetDimCorrectionSetBuffer."Multiple Target Set ID" = false then begin                                    SameTargetDimCorrectionSetBuffer."Multiple Target Set ID" := true;                                    SameTargetDimCorrectionSetBuffer.Modify();                                end;                            end;                            DimCorrectionSetBuffer.Insert();                            IncrementAndCommitIfNeeded(CommitCounter);                        end;        until DimCorrectSelectionCriteria.Next() = 0;        DimensionCorrection.GetBySystemId(DimensionCorrection.SystemId);        DimensionCorrection."Generated Set IDs" := true;        DimensionCorrection.Modify();    end;    /// <summary>    /// Creates a dimension correction from selected G/L register entries.    /// </summary>    /// <param name="GLRegister">G/L register entries to create correction from</param>    /// <param name="DimensionCorrection">Dimension correction record to populate</param>    procedure CreateCorrectionFromGLRegister(var GLRegister: Record "G/L Register"; var DimensionCorrection: Record "Dimension Correction")    var        LastDimensionCorrection: Record "Dimension Correction";        DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";        GLEntry: Record "G/L Entry";        GLEntryRecordRef: RecordRef;        NewEntryNo: Integer;    begin        GLRegister.FindSet();        NewEntryNo := 1;        if LastDimensionCorrection.FindLast() then            NewEntryNo := LastDimensionCorrection."Entry No." + 1;        DimensionCorrection."Entry No." := NewEntryNo;        DimensionCorrection.Insert(true);        repeat            GLEntry.SetRange("Entry No.", GLRegister."From Entry No.", GLRegister."To Entry No.");            TransferSelectionFilterToRecordRef(GLEntry, GLEntryRecordRef);            InsertNewDimCorrectSelectionCriteria(GLEntryRecordRef, DimCorrectSelectionCriteria."Filter Type"::Manual, DimCorrectSelectionCriteria, NewEntryNo);            Clear(DimCorrectSelectionCriteria);        until GLRegister.Next() = 0;        ReloadDimensionChangesTable(NewEntryNo);    end;    /// <summary>    /// Creates a dimension correction from manually selected G/L entries.    /// </summary>    /// <param name="GLEntry">G/L entries to create correction from</param>    /// <param name="DimensionCorrection">Dimension correction record to populate</param>    procedure CreateCorrectionFromSelection(var GLEntry: Record "G/L Entry"; var DimensionCorrection: Record "Dimension Correction")    var        LastDimensionCorrection: Record "Dimension Correction";        DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";        GLEntryRecordRef: RecordRef;        NewEntryNo: Integer;    begin        NewEntryNo := 1;        if LastDimensionCorrection.FindLast() then            NewEntryNo := LastDimensionCorrection."Entry No." + 1;        DimensionCorrection."Entry No." := NewEntryNo;        DimensionCorrection.Insert(true);        TransferSelectionFilterToRecordRef(GLEntry, GLEntryRecordRef);        InsertNewDimCorrectSelectionCriteria(GLEntryRecordRef, DimCorrectSelectionCriteria."Filter Type"::Manual, DimCorrectSelectionCriteria, NewEntryNo);        ReloadDimensionChangesTable(NewEntryNo);    end;    /// <summary>    /// Creates a dimension correction from G/L entries based on filter criteria.    /// </summary>    /// <param name="GLEntry">G/L entries with applied filters to create correction from</param>    /// <param name="DimensionCorrection">Dimension correction record to populate</param>    procedure CreateCorrectionFromFilter(var GLEntry: Record "G/L Entry"; var DimensionCorrection: Record "Dimension Correction")    var        LastDimensionCorrection: Record "Dimension Correction";        DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";        GLEntryRecordRef: RecordRef;        NewEntryNo: Integer;    begin        NewEntryNo := 1;        if LastDimensionCorrection.FindLast() then            NewEntryNo := LastDimensionCorrection."Entry No." + 1;        DimensionCorrection."Entry No." := NewEntryNo;        DimensionCorrection.Insert(true);        GLEntryRecordRef.GetTable(GLEntry);        InsertNewDimCorrectSelectionCriteria(GLEntryRecordRef, DimCorrectSelectionCriteria."Filter Type"::"Custom Filter", DimCorrectSelectionCriteria, NewEntryNo);        ReloadDimensionChangesTable(NewEntryNo);    end;    /// <summary>    /// Inserts new dimension correction selection criteria based on record filters.    /// </summary>    /// <param name="MainRecordRef">Record reference with filters to extract criteria from</param>    /// <param name="DimCorrectSelectionCriteriaFilterType">Filter type for the selection criteria</param>    /// <param name="DimCorrectSelectionCriteria">Selection criteria record to populate</param>    /// <param name="DimensionCorrectionEntryNo">Dimension correction entry number</param>    procedure InsertNewDimCorrectSelectionCriteria(var MainRecordRef: RecordRef; DimCorrectSelectionCriteriaFilterType: Option; var DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria"; DimensionCorrectionEntryNo: Integer)    var        DimensionCorrectionMgt: Codeunit "Dimension Correction Mgt";        DimensionSetIds: List of [Integer];    begin        DimCorrectSelectionCriteria."Dimension Correction Entry No." := DimensionCorrectionEntryNo;        DimCorrectSelectionCriteria."Filter Type" := DimCorrectSelectionCriteriaFilterType;        DimCorrectSelectionCriteria.SetSelectionFilter(MainRecordRef);        DimCorrectSelectionCriteria.Insert(true);        DimensionCorrectionMgt.CalculateDimensionSetIds(DimensionSetIds, DimCorrectSelectionCriteria);        DimCorrectSelectionCriteria.SetDimensionSetIds(DimensionSetIds);        DimCorrectSelectionCriteria.Modify(true);    end;    /// <summary>    /// Generates a filter text for selected dimension set IDs from temporary dimension set entries.    /// </summary>    /// <param name="TempDimensionSetEntry">Temporary dimension set entries containing selected dimensions</param>    /// <returns>Filter text representing the selected dimension set IDs</returns>    procedure GetSelectedDimensionSetIDsFilter(var TempDimensionSetEntry: Record "Dimension Set Entry" temporary): Text    var        TempFoundDimensionSetIDInteger: Record "Integer" temporary;        SelectedDimensionSetFilter: Text;        LastAddedNumber: Integer;        CurrentNumber: Integer;    begin        GetSelectedDimensionSetIDs(TempDimensionSetEntry, TempFoundDimensionSetIDInteger);        TempFoundDimensionSetIDInteger.SetCurrentKey(Number);        TempFoundDimensionSetIDInteger.Ascending(true);        if not TempFoundDimensionSetIDInteger.FindSet() then            exit('');        LastAddedNumber := TempFoundDimensionSetIDInteger.Number;        SelectedDimensionSetFilter += Format(LastAddedNumber);        CurrentNumber := LastAddedNumber;        repeat            if TempFoundDimensionSetIDInteger.Number > CurrentNumber + 1 then begin                if LastAddedNumber <> CurrentNumber then                    SelectedDimensionSetFilter += '..' + Format(CurrentNumber) + '|' + Format(TempFoundDimensionSetIDInteger.Number)                else                    SelectedDimensionSetFilter += '|' + Format(TempFoundDimensionSetIDInteger.Number);                LastAddedNumber := TempFoundDimensionSetIDInteger.Number;            end;            CurrentNumber := TempFoundDimensionSetIDInteger.Number;        until TempFoundDimensionSetIDInteger.Next() = 0;        if LastAddedNumber <> CurrentNumber then            SelectedDimensionSetFilter += '..' + Format(CurrentNumber);        exit(SelectedDimensionSetFilter);    end;    /// <summary>    /// Retrieves selected dimension set IDs based on temporary dimension set entries.    /// </summary>    /// <param name="TempDimensionSetEntry">Temporary dimension set entries to find matching set IDs for</param>    /// <param name="TempFoundDimensionSetIDInteger">Temporary integer buffer to store found dimension set IDs</param>    procedure GetSelectedDimensionSetIDs(var TempDimensionSetEntry: Record "Dimension Set Entry" temporary; var TempFoundDimensionSetIDInteger: Record "Integer" temporary)    var        DimensionSetEntry: Record "Dimension Set Entry";    begin        if not TempDimensionSetEntry.FindFirst() then            exit;        TempFoundDimensionSetIDInteger.SetCurrentKey(Number);        TempFoundDimensionSetIDInteger.Ascending(true);        DimensionSetEntry.SetCurrentKey("Dimension Set ID");        DimensionSetEntry.Ascending(true);        repeat            DimensionSetEntry.SetRange("Dimension Code", TempDimensionSetEntry."Dimension Code");            if TempDimensionSetEntry."Dimension Value Code" <> '' then                DimensionSetEntry.SetFilter("Dimension Value Code", TempDimensionSetEntry."Dimension Value Code");            if DimensionSetEntry.FindFirst() then begin                TempFoundDimensionSetIDInteger.Number := DimensionSetEntry."Dimension Set ID";                TempFoundDimensionSetIDInteger.Insert();                TempFoundDimensionSetIDInteger.Mark(true);            end;            DimensionSetEntry.SetFilter("Dimension Set ID", '>%1', DimensionSetEntry."Dimension Set ID");        until DimensionSetEntry.Next() = 0;        TempFoundDimensionSetIDInteger.MarkedOnly(true);        if not TempFoundDimensionSetIDInteger.FindFirst() then            exit;        if TempDimensionSetEntry.Next() = 0 then            exit;        repeat            repeat                DimensionSetEntry.SetRange("Dimension Set ID", TempFoundDimensionSetIDInteger.Number);                DimensionSetEntry.SetRange("Dimension Code", TempDimensionSetEntry."Dimension Code");                if TempDimensionSetEntry."Dimension Value Code" <> '' then                    DimensionSetEntry.SetRange("Dimension Value Code", TempDimensionSetEntry."Dimension Value Code");                if DimensionSetEntry.IsEmpty() then                    TempFoundDimensionSetIDInteger.Mark(false);            until TempFoundDimensionSetIDInteger.Next() = 0;            if not TempFoundDimensionSetIDInteger.FindFirst() then                exit;        until TempDimensionSetEntry.Next() = 0;    end;    local procedure TransformDimensionSet(DimensionSetID: Integer; var TempDimCorrectionChange: Record "Dim Correction Change" temporary; var NewDimensionSetID: Integer): Boolean    var        TempDimensionSetEntry: Record "Dimension Set Entry" temporary;        TempNewDimensionSetEntry: Record "Dimension Set Entry" temporary;        DimensionManagement: Codeunit "DimensionManagement";        Changed: Boolean;        EntryExist: Boolean;    begin        DimensionManagement.GetDimensionSet(TempDimensionSetEntry, DimensionSetId);        TempDimCorrectionChange.Reset();        if not TempDimCorrectionChange.FindFirst() then            exit(false);        repeat            case TempDimCorrectionChange."Change Type" of                TempDimCorrectionChange."Change Type"::Add,                TempDimCorrectionChange."Change Type"::Change:                    begin                        EntryExist := TempDimensionSetEntry.Get(DimensionSetID, TempDimCorrectionChange."Dimension Code");                        TempDimensionSetEntry."Dimension Code" := TempDimCorrectionChange."Dimension Code";                        TempDimensionSetEntry."Dimension Value ID" := TempDimCorrectionChange."New Value ID";                        TempDimensionSetEntry."Dimension Value Code" := CopyStr(TempDimCorrectionChange."New Value", 1, MaxStrLen(TempDimensionSetEntry."Dimension Value Code"));                        if EntryExist then                            TempDimensionSetEntry.Modify()                        else                            TempDimensionSetEntry.Insert();                        Changed := true;                    end;                TempDimCorrectionChange."Change Type"::Remove:                    if TempDimensionSetEntry.Get(DimensionSetID, TempDimCorrectionChange."Dimension Code") then begin                        TempDimensionSetEntry.Delete();                        Changed := true;                    end;            end;        until TempDimCorrectionChange.Next() = 0;        if Changed then            if TempDimensionSetEntry.FindFirst() then begin                repeat                    TempNewDimensionSetEntry.TransferFields(TempDimensionSetEntry, true);                    TempNewDimensionSetEntry."Dimension Set ID" := 0;                    OnTransformDimensionSetOnBeforeInsertTempNewDimensionSetEntry(TempNewDimensionSetEntry);                    TempNewDimensionSetEntry.Insert(true);                until TempDimensionSetEntry.Next() = 0;                NewDimensionSetID := DimensionManagement.GetDimensionSetID(TempNewDimensionSetEntry);            end;        exit(Changed);    end;    /// <summary>    /// Transfers selection filter from G/L Entry record to a record reference for filter processing.    /// </summary>    /// <param name="GLEntry">G/L entry record with selection filters applied</param>    /// <param name="GLEntryRecordRef">Record reference to transfer filters to</param>    procedure TransferSelectionFilterToRecordRef(var GLEntry: Record "G/L Entry"; var GLEntryRecordRef: RecordRef)    var        SelectionFilterManagement: Codeunit SelectionFilterManagement;        EntryNoFieldRef: FieldRef;        FilteredText: Text;    begin        GLEntryRecordRef.GetTable(GLEntry);        FilteredText := SelectionFilterManagement.GetSelectionFilter(GLEntryRecordRef, GLEntry.FieldNo("Entry No."));        GLEntryRecordRef.ClearMarks();        EntryNoFieldRef := GLEntryRecordRef.Field(GLEntry.FieldNo("Entry No."));        EntryNoFieldRef.SetFilter(FilteredText);    end;    /// <summary>    /// Retrieves dimension correction changes for a specific dimension correction entry.    /// </summary>    /// <param name="DimensionCorrectionEntryNo">Dimension correction entry number to get changes for</param>    /// <param name="TempDimCorrectionChange">Temporary record to store correction changes</param>    /// <returns>True if correction changes were found, false otherwise</returns>    procedure GetDimCorrectionChanges(DimensionCorrectionEntryNo: Integer; var TempDimCorrectionChange: Record "Dim Correction Change" temporary): Boolean    var        DimCorrectionChange: Record "Dim Correction Change";    begin        DimCorrectionChange.SetRange("Dimension Correction Entry No.", DimensionCorrectionEntryNo);        DimCorrectionChange.SetFilter("Change Type", '<>%1', DimCorrectionChange."Change Type"::"No Change");        if not DimCorrectionChange.FindSet() then            exit(false);        repeat            TempDimCorrectionChange.TransferFields(DimCorrectionChange, true);            TempDimCorrectionChange.Insert();        until DimCorrectionChange.Next() = 0;        exit(true);    end;    /// <summary>    /// Retrieves selection criteria for a dimension correction entry.    /// </summary>    /// <param name="DimensionCorrectionEntryNo">Dimension correction entry number to get selection criteria for</param>    /// <param name="DimCorrectSelectionCriteria">Record to store selection criteria</param>    /// <returns>True if selection criteria were found, false otherwise</returns>    procedure GetSelectionCriteria(DimensionCorrectionEntryNo: Integer; var DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria"): Boolean    begin        DimCorrectSelectionCriteria.SetRange("Dimension Correction Entry No.", DimensionCorrectionEntryNo);        DimCorrectSelectionCriteria.SetFilter("Filter Type", '<>%1', DimCorrectSelectionCriteria."Filter Type"::Excluded);        exit(DimCorrectSelectionCriteria.FindSet());    end;    /// <summary>    /// Calculates dimension set IDs based on selection criteria filters.    /// </summary>    /// <param name="DimensionSetIds">List to store calculated dimension set IDs</param>    /// <param name="DimCorrectSelectionCriteria">Selection criteria containing filters</param>    procedure CalculateDimensionSetIds(var DimensionSetIds: List of [Integer]; var DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria")    var        GLEntry: Record "G/L Entry";        SelectionFilter: Text;    begin        Clear(DimensionSetIds);        DimCorrectSelectionCriteria.GetSelectionFilter(SelectionFilter);        GLEntry.FilterGroup(2);        GLEntry.SetView(SelectionFilter);        GLEntry.FilterGroup(0);        GLEntry.SetCurrentKey("Dimension Set ID", "Entry No.");        GLEntry.Ascending(true);        if not GLEntry.FindFirst() then            exit;        repeat            if not IsEntryExclued(GLEntry, DimCorrectSelectionCriteria."Dimension Correction Entry No.") then begin                DimensionSetIds.Add(GLEntry."Dimension Set ID");                GLEntry.SetFilter("Dimension Set ID", '>%1', GLEntry."Dimension Set ID");            end;        until GLEntry.Next() = 0;    end;    /// <summary>    /// Reloads dimension changes table by recalculating changes based on current selection criteria.    /// </summary>    /// <param name="DimCorrectionEntryNo">Dimension correction entry number to reload changes for</param>    procedure ReloadDimensionChangesTable(DimCorrectionEntryNo: Integer)    var        DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";        DimCorrectionChange: Record "Dim Correction Change";        DimensionCodeValue: Dictionary of [Code[20], List of [Integer]];    begin        DimCorrectionChange.SetRange("Dimension Correction Entry No.", DimCorrectionEntryNo);        DimCorrectionChange.SetFilter("Change Type", '<>%1', DimCorrectionChange."Change Type"::"No Change");        if not DimCorrectionChange.IsEmpty() then            Message(ChangesWereResetMsg);        DimCorrectionChange.SetRange("Change Type");        DimCorrectionChange.DeleteAll(true);        DimCorrectSelectionCriteria.SetRange("Dimension Correction Entry No.", DimCorrectionEntryNo);        if not DimCorrectSelectionCriteria.FindSet() then            exit;        GetDimensionCodeValues(DimensionCodeValue, DimCorrectSelectionCriteria);        UpdateDimCorrectionChanges(DimensionCodeValue, DimCorrectionEntryNo);    end;    /// <summary>    /// Loads dimension correction set buffer data into a temporary record.    /// </summary>    /// <param name="DimensionCorrectionEntryNo">Dimension correction entry number to load data for</param>    /// <param name="TempDimCorrectionSetBuffer">Temporary buffer to store correction set data</param>    /// <returns>True if correction set buffer data was loaded, false otherwise</returns>    procedure LoadTempDimCorrectionSetBuffer(DimensionCorrectionEntryNo: Integer; var TempDimCorrectionSetBuffer: Record "Dim Correction Set Buffer" temporary): Boolean    var        DimCorrectionSetBuffer: Record "Dim Correction Set Buffer";    begin        DimCorrectionSetBuffer.SetRange("Dimension Correction Entry No.", DimensionCorrectionEntryNo);        if not DimCorrectionSetBuffer.FindSet() then            exit(false);        repeat            TempDimCorrectionSetBuffer.TransferFields(DimCorrectionSetBuffer, true);            TempDimCorrectionSetBuffer.Insert();            if DimCorrectionSetBuffer."Multiple Target Set ID" then begin                TempDimCorrectionSetBuffer.SetLedgerEntries(DimCorrectionSetBuffer.GetSetLedgerEntries());                TempDimCorrectionSetBuffer.Modify();            end;        until DimCorrectionSetBuffer.Next() = 0;        exit(true);    end;    /// <summary>    /// Schedules a job queue entry to run dimension correction.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction to schedule for execution</param>    /// <returns>True if job was successfully scheduled, false otherwise</returns>    procedure ScheduleRunJob(var DimensionCorrection: Record "Dimension Correction"): Boolean    var        JobQueueEntry: Record "Job Queue Entry";    begin        CreateUniqueJobQueue(Codeunit::"Dim Correction Run", DimensionCorrection, JobQueueEntry);        Commit();        if ScheduleJobViaUI(JobQueueEntry, '') then begin            SetStatusInProgress(DimensionCorrection);            DimensionCorrection."Last Job Queue Entry ID" := JobQueueEntry.ID;            DimensionCorrection.Modify();            exit(true);        end;        exit(false);    end;    /// <summary>    /// Schedules a job queue entry to undo dimension correction.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction to schedule for undo</param>    /// <returns>True if undo job was successfully scheduled, false otherwise</returns>    procedure ScheduleUndoJob(var DimensionCorrection: Record "Dimension Correction"): Boolean    var        JobQueueEntry: Record "Job Queue Entry";    begin        CreateUniqueJobQueue(Codeunit::"Dimension Correction Undo", DimensionCorrection, JobQueueEntry);        Commit();        if ScheduleJobViaUI(JobQueueEntry, UndoDimensionCorrectionLbl) then begin            SetUndoStatusInProgress(DimensionCorrection);            DimensionCorrection."Last Job Queue Entry ID" := JobQueueEntry.ID;            DimensionCorrection.Modify();            exit(true);        end;        exit(false);    end;    /// <summary>    /// Schedules a job queue entry to validate dimension correction.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction to schedule for validation</param>    /// <returns>True if validation job was successfully scheduled, false otherwise</returns>    procedure ScheduleValidationJob(var DimensionCorrection: Record "Dimension Correction"): Boolean    var        JobQueueEntry: Record "Job Queue Entry";    begin        CreateUniqueJobQueue(Codeunit::"Dim Correction Validate", DimensionCorrection, JobQueueEntry);        Commit();        if ScheduleJobViaUI(JobQueueEntry, ValidateDimensionCorrectionLbl) then begin            DeleteValidationErrors(DimensionCorrection);            ClearValidationFields(DimensionCorrection);            SetValidatingStatusInProgress(DimensionCorrection);            DimensionCorrection."Last Job Queue Entry ID" := JobQueueEntry.ID;            DimensionCorrection.Modify();            exit(true);        end else            exit(false);    end;    /// <summary>    /// Schedules a job queue entry to update analysis views after dimension correction.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction to schedule analysis view updates for</param>    /// <returns>True if analysis view update job was successfully scheduled, false otherwise</returns>    procedure ScheduleUpdateAnalysisViews(var DimensionCorrection: Record "Dimension Correction"): Boolean    var        JobQueueEntry: Record "Job Queue Entry";    begin        CreateUniqueJobQueue(Codeunit::"Dim Corr Analysis View", DimensionCorrection, JobQueueEntry);        Commit();        if GuiAllowed then            exit(ScheduleJobViaUI(JobQueueEntry, UpdateAnalysisViewsLbl));        JobQueueEntry.SetStatus(JobQueueEntry.Status::Ready);        exit(true);    end;    local procedure ScheduleJobViaUI(var JobQueueEntry: Record "Job Queue Entry"; NewCaption: Text): Boolean    var        DimCorrectionSchedule: Page "Dim Correction Schedule";    begin        if NewCaption <> '' then            DimCorrectionSchedule.SetNewCaption(NewCaption);        DimCorrectionSchedule.SetRecord(JobQueueEntry);        if DimCorrectionSchedule.RunModal() in [Action::Cancel, Action::LookupCancel] then            exit(false);        exit(true);    end;    /// <summary>    /// Updates the status of a dimension correction based on job queue entry status.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to update status for</param>    procedure UpdateStatus(var DimensionCorrection: Record "Dimension Correction")    var        JobQueueEntry: Record "Job Queue Entry";    begin        if not (DimensionCorrection.Status in [DimensionCorrection.Status::"In Process", DimensionCorrection.Status::"Undo in Process", DimensionCorrection.Status::"Validaton in Process"]) then            exit;        if not JobQueueEntry.Get(DimensionCorrection."Last Job Queue Entry ID") then begin            DimensionCorrection.Status := DimensionCorrection.Status::Failed;            DimensionCorrection.Modify();            exit;        end;        if JobQueueEntry.Status = JobQueueEntry.Status::Error then begin            DimensionCorrection.Status := DimensionCorrection.Status::Failed;            DimensionCorrection."Error Message" := JobQueueEntry."Error Message";            DimensionCorrection.Modify();            exit;        end;        if JobQueueEntry.Status = JobQueueEntry.Status::Finished then begin            DimensionCorrection.Status := DimensionCorrection.Status::Completed;            Clear(DimensionCorrection."Error Message");            DimensionCorrection.Modify();            exit;        end;    end;    /// <summary>    /// Updates the analysis view status for dimension correction based on job queue entry status.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to update analysis view status for</param>    procedure UpdateAnalysisViewStatus(var DimensionCorrection: Record "Dimension Correction")    var        JobQueueEntry: Record "Job Queue Entry";    begin        if not (DimensionCorrection."Update Analysis Views Status" = DimensionCorrection."Update Analysis Views Status"::"In Process") then            exit;        if not JobQueueEntry.Get(DimensionCorrection."Update Analysis View Job ID") then begin            DimensionCorrection."Update Analysis Views Status" := DimensionCorrection."Update Analysis Views Status"::Failed;            DimensionCorrection.Modify();            exit;        end;        if JobQueueEntry.Status = JobQueueEntry.Status::Error then begin            DimensionCorrection."Update Analysis Views Status" := DimensionCorrection."Update Analysis Views Status"::Failed;            DimensionCorrection.SetUpdateAnalysisViewErrorMessage(JobQueueEntry."Error Message");            DimensionCorrection.Modify();            exit;        end;        if JobQueueEntry.Status = JobQueueEntry.Status::Finished then begin            DimensionCorrection."Update Analysis Views Status" := DimensionCorrection."Update Analysis Views Status"::Completed;            Clear(DimensionCorrection."Update Analysis Views Error");            DimensionCorrection.Modify();            exit;        end;    end;    local procedure CreateUniqueJobQueue(CodeunitID: Integer; var DimensionCorrection: Record "Dimension Correction"; var JobQueueEntry: Record "Job Queue Entry")    var        JobQueueExist: Boolean;    begin        JobQueueEntry.SetRange("Object Type to Run", JobQueueEntry."Object Type to Run"::Codeunit);        JobQueueEntry.SetRange("Object ID to Run", CodeunitID);        JobQueueExist := JobQueueEntry.FindFirst();        if JobQueueExist then begin            if JobQueueEntry.Status = JobQueueEntry.Status::"In Process" then                Error(JobQueueIsRunningErr);            JobQueueEntry.Delete(true);            Clear(JobQueueEntry);        end;        JobQueueEntry."Object Type to Run" := JobQueueEntry."Object Type to Run"::Codeunit;        JobQueueEntry."Object ID to Run" := CodeunitID;        JobQueueEntry."Maximum No. of Attempts to Run" := 1;        JobQueueEntry."Recurring Job" := false;        JobQueueEntry."Record ID to Process" := DimensionCorrection.RecordId;        JobQueueEntry.Status := JobQueueEntry.Status::"On Hold";        JobQueueEntry."Job Queue Category Code" := JobQueueCategoryCodeTxt;        Clear(JobQueueEntry."Error Message");        Clear(JobQueueEntry."Error Message Register Id");        JobQueueEntry.Description := CopyStr(StrSubstNo(JobQueueEntryDescTxt, DimensionCorrection."Entry No."), 1, MaxStrLen(JobQueueEntry.Description));        JobQueueEntry.Insert(true);    end;    /// <summary>    /// Verifies that a dimension correction job can be started by checking for conflicts with other running jobs.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction to verify for job start</param>    procedure VerifyCanStartJob(DimensionCorrection: Record "Dimension Correction")    var        InProgressDimensionCorrection: Record "Dimension Correction";    begin        if not DimensionCorrection.Completed then            if DimensionCorrection.Status = DimensionCorrection.Status::"In Process" then                Error(JobAlreadyInProgressErr);        if DimensionCorrection.Completed then            if DimensionCorrection.Status = DimensionCorrection.Status::"Undo In Process" then                Error(JobAlreadyInProgressErr);        InProgressDimensionCorrection.SetFilter(Status, '%1|%2|%3', DimensionCorrection.Status::"In Process", DimensionCorrection.Status::"Undo in Process", DimensionCorrection.Status::"Validaton in Process");        InProgressDimensionCorrection.SetLoadFields("Entry No.", Status);        if InProgressDimensionCorrection.FindFirst() then            UpdateStatus(InProgressDimensionCorrection);        if InProgressDimensionCorrection.FindFirst() then            Error(AnotherJobAlreadyInProgressErr, InProgressDimensionCorrection."Entry No.");    end;    /// <summary>    /// Sets dimension correction status to in progress and clears error information.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to set in progress</param>    procedure SetStatusInProgress(var DimensionCorrection: Record "Dimension Correction")    begin        DimensionCorrection.Status := DimensionCorrection.Status::"In Process";        Clear(DimensionCorrection."Error Message");        DeleteValidationErrors(DimensionCorrection);        if DimensionCorrection."Validated At" <> 0DT then            ClearValidationFields(DimensionCorrection);        DimensionCorrection.Modify();        Commit();    end;    /// <summary>    /// Sets dimension correction status to undo in progress and clears error information.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to set undo in progress</param>    procedure SetUndoStatusInProgress(var DimensionCorrection: Record "Dimension Correction")    begin        DimensionCorrection.Status := DimensionCorrection.Status::"Undo in Process";        Clear(DimensionCorrection."Error Message");        DeleteValidationErrors(DimensionCorrection);        if DimensionCorrection."Validated At" <> 0DT then            ClearValidationFields(DimensionCorrection);        DimensionCorrection.Modify();        Commit();    end;    /// <summary>    /// Sets dimension correction status to validation in progress and clears validation fields.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to set validation in progress</param>    procedure SetValidatingStatusInProgress(var DimensionCorrection: Record "Dimension Correction")    begin        DimensionCorrection.Status := DimensionCorrection.Status::"Validaton in Process";        Clear(DimensionCorrection."Error Message");        Clear(DimensionCorrection."Last Validated Entry No.");        DeleteValidationErrors(DimensionCorrection);        DimensionCorrection.Modify();        Commit();    end;    /// <summary>    /// Gets formatted validation status text for dimension correction.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction to get validation status for</param>    /// <param name="ErrorMessage">Error message text to include if validation failed</param>    /// <returns>Formatted validation status text</returns>    procedure GetValidationStatusText(var DimensionCorrection: Record "Dimension Correction"; ErrorMessage: Text): Text    begin        if DimensionCorrection."Validated At" = 0DT then            exit('');        if DimensionCorrection."Validated Selected Entries" then begin            if DimensionCorrection.Completed then                exit(StrSubstNo(ValidationUndoPassedLbl, DimensionCorrection."Validated At"));            exit(StrSubstNo(ValidationDraftPassedLbl, DimensionCorrection."Validated At"));        end;        exit(StrSubstNo(ValidationFailedLbl, DimensionCorrection."Validated At", ErrorMessage));    end;    /// <summary>    /// Creates a draft copy of an existing dimension correction with all selection criteria.    /// </summary>    /// <param name="DimensionCorrection">Original dimension correction to copy from</param>    /// <param name="NewDimensionCorrection">New dimension correction record to populate</param>    procedure CopyToDraft(var DimensionCorrection: Record "Dimension Correction"; var NewDimensionCorrection: Record "Dimension Correction")    var        DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";        NewDimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";        SelectionFilter: Text;        DimensionSetIds: List of [Integer];    begin        NewDimensionCorrection.Description := DimensionCorrection.Description;        NewDimensionCorrection.Insert(true);        DimCorrectSelectionCriteria.SetRange("Dimension Correction Entry No.", DimensionCorrection."Entry No.");        if not DimCorrectSelectionCriteria.FindSet() then            exit;        repeat            Clear(NewDimCorrectSelectionCriteria);            NewDimCorrectSelectionCriteria.TransferFields(DimCorrectSelectionCriteria);            NewDimCorrectSelectionCriteria."Dimension Correction Entry No." := NewDimensionCorrection."Entry No.";            DimCorrectSelectionCriteria.GetSelectionFilter(SelectionFilter);            NewDimCorrectSelectionCriteria.SetSelectionFilter(SelectionFilter);            NewDimCorrectSelectionCriteria."Entry No." := 0;            NewDimCorrectSelectionCriteria."Last Entry No." := 0;            NewDimCorrectSelectionCriteria.Insert(true);            CalculateDimensionSetIds(DimensionSetIds, NewDimCorrectSelectionCriteria);            NewDimCorrectSelectionCriteria.SetDimensionSetIds(DimensionSetIds);            NewDimCorrectSelectionCriteria.Modify(true);        until DimCorrectSelectionCriteria.Next() = 0;        ReloadDimensionChangesTable(NewDimensionCorrection."Entry No.");    end;    local procedure ClearValidationFields(var DimensionCorrection: Record "Dimension Correction")    begin        Clear(DimensionCorrection."Validated At");        Clear(DimensionCorrection."Validated Selected Entries");        Clear(DimensionCorrection."Validation Errors Register ID");        Clear(DimensionCorrection."Last Validated Entry No.");        Clear(DimensionCorrection."Error Message");        Clear(DimensionCorrection."Validation Message");    end;    local procedure GetDimensionCodeValues(var DimensionCodeValue: Dictionary of [Code[20], List of [Integer]]; var DimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria")    var        DimensionSetIdList: List of [Integer];        DimensionSetId: Integer;        ProcessedDimensionSetIds: List of [Integer];    begin        if not DimCorrectSelectionCriteria.FindSet() then            exit;        repeat            DimCorrectSelectionCriteria.GetDimensionSetIds(DimensionSetIdList);            foreach DimensionSetId in DimensionSetIdList do                if not ProcessedDimensionSetIds.Contains(DimensionSetId) then begin                    AddDimensionSetIDToDictionary(DimensionSetId, DimensionCodeValue);                    ProcessedDimensionSetIds.Add(DimensionSetId);                end;        until DimCorrectSelectionCriteria.Next() = 0;    end;    local procedure AddDimensionSetIDToDictionary(DimensionsetId: Integer; var DimensionCodeValue: Dictionary of [Code[20], List of [Integer]])    var        DimensionSetEntry: Record "Dimension Set Entry";        DimensionValues: List of [Integer];    begin        DimensionSetEntry.SetRange("Dimension Set ID", DimensionSetId);        if DimensionSetEntry.FindSet() then            repeat                Clear(DimensionValues);                if not DimensionCodeValue.ContainsKey(DimensionSetEntry."Dimension Code") then                    DimensionCodeValue.Add(DimensionSetEntry."Dimension Code", DimensionValues)                else                    DimensionCodeValue.Get(DimensionSetEntry."Dimension Code", DimensionValues);                if not DimensionValues.Contains(DimensionSetEntry."Dimension Value ID") then                    DimensionValues.Add(DimensionSetEntry."Dimension Value ID");            until DimensionSetEntry.Next() = 0;    end;    local procedure UpdateDimCorrectionChanges(var DimensionCodeValue: Dictionary of [Code[20], List of [Integer]]; DimensionCorrectionEntryNo: Integer): Boolean    var        DimCorrectionChange: Record "Dim Correction Change";        DimensionSetEntry: Record "Dimension Set Entry";        DimensionCode: Code[20];        DimensionValues: List of [Integer];        EntryExists: Boolean;    begin        if DimensionCodeValue.Keys().Count() = 0 then            exit;        foreach DimensionCode in DimensionCodeValue.Keys() do begin            DimensionValues := DimensionCodeValue.Get(DimensionCode);            Clear(DimCorrectionChange);            EntryExists := DimCorrectionChange.Get(DimensionCorrectionEntryNo, DimensionCode);            DimCorrectionChange."Dimension Correction Entry No." := DimensionCorrectionEntryNo;            DimCorrectionChange."Dimension Code" := DimensionCode;            DimCorrectionChange."Dimension Value Count" := DimensionValues.Count();            DimCorrectionChange.SetDimensionValues(DimensionValues);            if DimCorrectionChange."Dimension Value Count" = 1 then begin                DimensionSetEntry.SetRange("Dimension Value ID", DimensionValues.Get(1));                if DimensionSetEntry.FindFirst() then                    DimCorrectionChange."Dimension Value" := DimensionSetEntry."Dimension Value Code"                else                    DimCorrectionChange."Dimension Value" := Format(DimensionValues.Get(1));            end;            if EntryExists then                DimCorrectionChange.Modify(true)            else                DimCorrectionChange.Insert(true);        end;    end;    /// <summary>    /// Determines if a G/L entry is excluded from dimension correction based on exclusion criteria.    /// </summary>    /// <param name="GLEntry">G/L entry to check for exclusion</param>    /// <param name="DimensionCorrectionEntryNo">Dimension correction entry number containing exclusion criteria</param>    /// <returns>True if entry is excluded, false otherwise</returns>    procedure IsEntryExclued(var GLEntry: Record "G/L Entry"; DimensionCorrectionEntryNo: Integer): Boolean    var        ExcludedDimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria";    begin        ExcludedDimCorrectSelectionCriteria.SetRange("Dimension Correction Entry No.", DimensionCorrectionEntryNo);        ExcludedDimCorrectSelectionCriteria.SetRange("Filter Type", ExcludedDimCorrectSelectionCriteria."Filter Type"::Excluded);        exit(IsEntryExclued(GLEntry, ExcludedDimCorrectSelectionCriteria));    end;    /// <summary>    /// Determines if a G/L entry is excluded based on specific exclusion selection criteria.    /// </summary>    /// <param name="GLEntry">G/L entry to check for exclusion</param>    /// <param name="ExcludedDimCorrectSelectionCriteria">Exclusion selection criteria to evaluate against</param>    /// <returns>True if entry is excluded, false otherwise</returns>    procedure IsEntryExclued(var GLEntry: Record "G/L Entry"; var ExcludedDimCorrectSelectionCriteria: Record "Dim Correct Selection Criteria"): Boolean    var        TempGLEntry: Record "G/L Entry" temporary;        SelectionFilter: Text;    begin        if not ExcludedDimCorrectSelectionCriteria.FindSet() then            exit;        TempGLEntry.Copy(GLEntry);        TempGLEntry.Insert();        repeat            ExcludedDimCorrectSelectionCriteria.GetSelectionFilter(SelectionFilter);            TempGLEntry.SetView(SelectionFilter);            if not TempGLEntry.IsEmpty() then                exit(true);        until ExcludedDimCorrectSelectionCriteria.Next() = 0;        exit(false);    end;    /// <summary>    /// Increments a counter and commits database changes if the commit threshold is reached.    /// </summary>    /// <param name="Counter">Counter to increment and check against commit threshold</param>    procedure IncrementAndCommitIfNeeded(var Counter: Integer)    begin        Counter += 1;        if Counter >= GetCommitCount() then begin            Commit();            Session.LogMessage('0000EHT', StrSubstNo(CommitingTelemetryLbl, GetCommitCount()), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', DimensionCorrectionTok);            Counter := 0;        end;    end;    local procedure GetDictionarySizeLimit(): Integer    begin        exit(100000);    end;    /// <summary>    /// Gets the maximum number of validation errors allowed before stopping validation.    /// </summary>    /// <returns>Maximum number of validation errors (50000)</returns>    procedure GetMaximumNumberOfValidationErrors(): Integer    begin        exit(50000);    end;    /// <summary>    /// Gets the number of operations after which database changes should be committed.    /// </summary>    /// <returns>Commit count threshold</returns>    procedure GetCommitCount(): Integer;    var        Handled: Boolean;        CommitCount: Integer;    begin        OnGetCommitCount(Handled, CommitCount);        if Handled then            exit(CommitCount);        exit(1000);    end;    /// <summary>    /// Gets the maximum number of G/L entries to show in preview mode.    /// </summary>    /// <returns>Preview G/L entries limit</returns>    procedure GetPreviewGLEntriesLimit(): Integer    var        Handled: Boolean;        PreviewCount: Integer;    begin        OnGetPreviewGLEntriesLimit(Handled, PreviewCount);        if Handled then            exit(PreviewCount);        exit(20000);    end;    /// <summary>    /// Gets the maximum number of filter conditions allowed in selection criteria.    /// </summary>    /// <returns>Filter conditions limit</returns>    procedure GetFilterConditionsLimit(): Integer;    var        Handled: Boolean;        FilterCount: Integer;    begin        OnGetFilterCount(Handled, FilterCount);        if Handled then            exit(FilterCount);        exit(2000);    end;    [EventSubscriber(ObjectType::Table, Database::"Job Queue Entry", 'OnAfterFinalizeRun', '', false, false)]    local procedure HandleJobQueueFailures(JobQueueEntry: Record "Job Queue Entry")    var        DimensionCorrection: Record "Dimension Correction";        ErrorMessage: Record "Error Message";        LastErrorMessage: Text[2048];    begin        if JobQueueEntry."Error Message" = '' then            exit;        if not DimensionCorrection.Get(JobQueueEntry."Record ID to Process") then            exit;        DimensionCorrection."Validation Errors Register ID" := JobQueueEntry."Error Message Register Id";        if not IsNullGuid(JobQueueEntry."Error Message Register Id") then begin            ErrorMessage.SetRange("Register ID", DimensionCorrection."Validation Errors Register ID");            if ErrorMessage.FindLast() then                LastErrorMessage := ErrorMessage."Message"            else                LastErrorMessage := JobQueueEntry."Error Message";        end;        if (JobQueueEntry."Object Type to Run" <> JobQueueEntry."Object Type to Run"::Codeunit) then            exit;        if not (JobQueueEntry."Object ID to Run" in [Codeunit::"Dim Correction Run", Codeunit::"Dimension Correction Undo", Codeunit::"Dim Corr Analysis View", Codeunit::"Dim Correction Validate"]) then            exit;        if JobQueueEntry."Object ID to Run" in [Codeunit::"Dim Correction Run", Codeunit::"Dimension Correction Undo"] then begin            DimensionCorrection.Status := DimensionCorrection.Status::Failed;            DimensionCorrection."Error Message" := LastErrorMessage;            DimensionCorrection.Modify(true);            exit;        end;        if JobQueueEntry."Object Type to Run" = Codeunit::"Dim Corr Analysis View" then begin            DimensionCorrection."Update Analysis Views Status" := DimensionCorrection."Update Analysis Views Status"::Failed;            DimensionCorrection.SetUpdateAnalysisViewErrorMessage(LastErrorMessage);            DimensionCorrection.Modify();            exit;        end;        if JobQueueEntry."Object ID to Run" = Codeunit::"Dim Correction Validate" then begin            if DimensionCorrection.Status = DimensionCorrection.Status::"Validaton in Process" then                if DimensionCorrection.Completed then                    DimensionCorrection.Status := DimensionCorrection.Status::Completed                else                    DimensionCorrection.Status := DimensionCorrection.Status::Draft;            DimensionCorrection."Validated Selected Entries" := false;            DimensionCorrection."Validated At" := CurrentDateTime();            DimensionCorrection.SetValidateDimensionChangesText(GetValidationStatusText(DimensionCorrection, LastErrorMessage));            DimensionCorrection.Modify();        end;    end;    /// <summary>    /// Sets the analysis views update status to completed and clears error messages.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction record to mark analysis views update as completed</param>    procedure SetUpdateAnalysisViewsCompleted(var DimensionCorrection: Record "Dimension Correction")    begin        DimensionCorrection."Update Analysis Views Status" := DimensionCorrection."Update Analysis Views Status"::Completed;        Clear(DimensionCorrection."Update Analysis Views Error");        DimensionCorrection.Modify();    end;    /// <summary>    /// Shows notification to update cost accounting manually after dimension correction.    /// </summary>    procedure ShowNotificationUpdateCashFlowAccounting()    var        MyNotifications: Record "My Notifications";        CostAccountingSetup: Record "Cost Accounting Setup";        ShowUpdateCostAccountingManually: Notification;    begin        if not CostAccountingSetup.Get() then            exit;        if not CostAccountingSetup."Auto Transfer from G/L" then            exit;        if MyNotifications.Get(UserId, GetUpdateCostAccountingNotificationID()) then            if not MyNotifications.Enabled then                exit;        ShowUpdateCostAccountingManually.Id := GetUpdateCostAccountingNotificationID();        if ShowUpdateCostAccountingManually.Recall() then;        ShowUpdateCostAccountingManually.Message := UpdateCostAccountingManuallyMsg;        ShowUpdateCostAccountingManually.Scope := NOTIFICATIONSCOPE::LocalScope;        ShowUpdateCostAccountingManually.AddAction(DontShowAgainTxt, CODEUNIT::"Dimension Correction Mgt", 'DontShowAgainUpdateCostAccounting');        ShowUpdateCostAccountingManually.Send();    end;    /// <summary>    /// Disables the cost accounting update notification to prevent future display.    /// </summary>    /// <param name="UpdateCostAcountingNotification">Notification being dismissed</param>    procedure DontShowAgainUpdateCostAccounting(UpdateCostAcountingNotification: Notification)    var        MyNotifications: Record "My Notifications";    begin        if not MyNotifications.Disable(GetUpdateCostAccountingNotificationID()) then            MyNotifications.InsertDefault(              GetUpdateCostAccountingNotificationID(), DimensionCorrectionCostAccountingNotificationNameTxt, DimensionCorrectionCostAccountingNotificationDescriptionTxt, false);    end;    local procedure GetUpdateCostAccountingNotificationID(): Guid    begin        exit('0bf7a209-d730-485b-9ad8-14dc1e756eaf');    end;    /// <summary>    /// Verifies that a dimension correction can be undone by checking if dimension sets are still valid.    /// </summary>    /// <param name="DimensionCorrection">Dimension correction to verify for undo capability</param>    procedure VerifyCanUndoDimensionCorrection(var DimensionCorrection: Record "Dimension Correction")    begin        DimensionCorrection.CalcFields(Invalidated);        if DimensionCorrection.Invalidated then            Error(DimensionSetIsInvalidErr);    end;    /// <summary>    /// Verifies that a draft dimension correction entry can be modified based on its current status.    /// </summary>    /// <param name="DimensionCorrectionEntryNo">Dimension correction entry number to verify for modification</param>    procedure VerifyCanModifyDraftEntry(DimensionCorrectionEntryNo: Integer)    var        DimensionCorrection: Record "Dimension Correction";    begin        if DimensionCorrectionEntryNo = 0 then            Error(InsertDimensionCorrectionFirstErr);        DimensionCorrection.Get(DimensionCorrectionEntryNo);        if not (DimensionCorrection.Status in [DimensionCorrection.Status::Failed, DimensionCorrection.Status::Draft]) then            Error(ModifyingDraftDimensionCorrectionNotAllowedErr, DimensionCorrection.Status);        if DimensionCorrection."Started Correction" then            Error(ModifyingDraftDimensionCorrectionNotAllowedReopenErr);    end;    /// <summary>    /// Integration event allowing customization of preview G/L entries limit.    /// </summary>    /// <param name="Handled">Set to true to override default limit</param>    /// <param name="Limit">Custom preview entries limit to use</param>    [IntegrationEvent(false, false)]    local procedure OnGetPreviewGLEntriesLimit(var Handled: Boolean; var Limit: Integer)    begin    end;    /// <summary>    /// Integration event allowing customization of commit count threshold.    /// </summary>    /// <param name="Handled">Set to true to override default commit count</param>    /// <param name="CommitCount">Custom commit count threshold to use</param>    [IntegrationEvent(false, false)]    local procedure OnGetCommitCount(var Handled: Boolean; var CommitCount: Integer)    begin    end;    /// <summary>    /// Integration event allowing customization of filter conditions limit.    /// </summary>    /// <param name="Handled">Set to true to override default filter count</param>    /// <param name="FilterCount">Custom filter conditions limit to use</param>    [IntegrationEvent(false, false)]    local procedure OnGetFilterCount(var Handled: Boolean; var FilterCount: Integer)    begin    end;    /// <summary>    /// Integration event raised after verifying if dimension can be changed.    /// </summary>    /// <param name="DimCorrectionChange">Dimension correction change record that was verified</param>    [IntegrationEvent(false, false)]    local procedure OnAfterVerifyIfDimensionCanBeChanged(var DimCorrectionChange: Record "Dim Correction Change")    begin    end;    /// <summary>    /// Integration event raised before inserting temporary new dimension set entry during dimension transformation.    /// </summary>    /// <param name="TempNewDimensionSetEntry">Temporary dimension set entry about to be inserted</param>    [IntegrationEvent(false, false)]    local procedure OnTransformDimensionSetOnBeforeInsertTempNewDimensionSetEntry(var TempNewDimensionSetEntry: Record "Dimension Set Entry" temporary)    begin    end;    var        CannotValidateDimensionCorrectionErr: Label 'You cannot validate dimension corrections that have the %1 status.', Comment = '%1 Status of dimension correction';        ValidateDimensionCorrectionLbl: Label 'Validate Dimension Correction';        UpdateCostAccountingManuallyMsg: Label 'A dimension correction may have affected reports for cost accounting. To help ensure the reports are accurate, recreate the cost accounting allocations.';        DimensionCorrectionCostAccountingNotificationNameTxt: Label 'Warn Update Cost Accounting After Dimension Correction';        DimensionCorrectionCostAccountingNotificationDescriptionTxt: Label 'Notifies users that a dimension correction may have affected reports for cost accounting, and that they may need to recreate allocations.';        DontShowAgainTxt: Label 'Do not show again';        ValidationFailedLbl: Label 'The validation of the dimension corrections that ran on %1 found the following errors: %2.', Comment = '%1 - Date time of last validation, %2 - Error message';        ValidationUndoPassedLbl: Label 'Validation was successful on %1. You can undo the dimension correction.', Comment = '%1 - Date time of last validation';        ValidationDraftPassedLbl: Label 'The dimension correction was validated on %1.', Comment = '%1 - Date time of last validation';        ValidationFailedErr: Label '%1 entries have validation errors on dimension changes. To review the errors, choose the Show Errors action.', Comment = '%1 count of validation errors';        JobQueueIsRunningErr: Label 'The job queue entry is already running. Stop the existing job queue entry to schedule a new one.';        JobQueueEntryDescTxt: Label 'Dimension Correction - %1.', Comment = '%1 - Unique number of the correction';        JobAlreadyInProgressErr: Label 'There is a job already in progress.';        AnotherJobAlreadyInProgressErr: Label 'Dimension correction %1 is in progress and must complete before you can start another correction.', Comment = '%1 - Entry No of another dimension correction';        ChangesWereResetMsg: Label 'Changes to the dimensions were reset because ledger entries were updated. We recommend that you change dimensions after selecting all ledger entries.';        CannotChangeDimensionCodeBlockedErr: Label 'Dimension %1 cannot be used because it is blocked for the correction.', Comment = '%1 code of the dimension';        JobQueueCategoryCodeTxt: Label 'DIMCORRECT', Locked = true;        DimensionSetIsInvalidErr: Label 'Cannot undo the dimension correction because other corrections were made more recently.';        ModifyingDraftDimensionCorrectionNotAllowedErr: Label 'You cannot change a dimension correction while it is in %1 state.', Comment = '%1 Name of the state';        ModifyingDraftDimensionCorrectionNotAllowedReopenErr: Label 'You need to reopen the dimension correction to do changes. Alternatevelly you can schedule a new run.';        InsertDimensionCorrectionFirstErr: Label 'You must create Dimension Correction first, for example by entering description';        CommitingTelemetryLbl: Label 'Commiting after %1 entries processed.', Locked = true, Comment = '%1 Number of entries procesed';        UndoDimensionCorrectionLbl: Label 'Undo Dimension Correction';        UpdateAnalysisViewsLbl: Label 'Update Analysis Views';        StartingValidateDimensionChangesForEntriesLbl: Label 'Starting Validate Dimension Changes for Entries, Dimension Correction - %1', Locked = true, Comment = '%1 - Number of Dimension Correction';        CompletedValidateDimensionChangesForEntriesLbl: Label 'Completed Validate Dimension Changes for Entries, Dimension Correction - %1', Locked = true, Comment = '%1 - Number of Dimension Correction';        InvalidDimensionCorrectionErr: Label 'The dimension correction for Entry %1 is invalid. Error message: %2', Comment = '%1 - Ledger entry number, %2 Error message.';        CommitedValidateGLEntriesLbl: Label 'Commited G/L Entries validation. Dimension Correction Entry No.: %1, Time from last commit: %2. Number of entries iterated: %3.', Locked = true, Comment = '%1 Dimension Correction Entry No., %2 - Time passed between commits, %3 Number, %4 Time validating dimensions';        StartingGenerateDimensionSetIdsLbl: Label 'Starting Generate Dimension Correction Set IDs, Dimension Correction Entry No.: %1.', Locked = true, Comment = '%1 Dimension Correction Entry No.';        CompletedGenerateDimensionSetIdsLbl: Label 'Completed Generate Dimension Correction Set IDs, Dimension Correction Entry No.: %1.', Locked = true, Comment = '%1 Dimension Correction Entry No.';        NoLedgerEntriesFoundErr: Label 'No ledger entries were found for this dimension correction';        NoSelectionCriteriaFoundErr: Label 'No selection criteria was found for this dimension correction.';        NoChangesFoundErr: Label 'No dimension values need to be updated.';        StartingGenerateSelectedEntriesLbl: Label 'Starting Generate Selected Entries, Dimension Correction Entry No.: %1.', Locked = true, Comment = '%1 Dimension Correction Entry No.';        CompletedGenerateSelectedEntriesLbl: Label 'Completed Generate Selected Entries, Dimension Correction Entry No.: %1.', Locked = true, Comment = '%1 Dimension Correction Entry No.';        StartingValidateDimensionCorrectionChangesTelemetryLbl: Label 'Starting Validate Dimension Correction Changes, Dimension Correction Entry No.: %1', Locked = true, Comment = '%1 Dimension Correction Entry No.';        CompletedValidateDimensionCorrectionChangesTelemetryLbl: Label 'Completed Validate Dimension Correction Changes, Dimension Correction Entry No.: %1.', Locked = true, Comment = '%1 Dimension Correction Entry No., %2 number of updated entries';        DimensionCorrectionTok: Label 'DimensionCorrection', Locked = true;}