Codeunit 2580 Dimension Correction Mgt
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;}