Codeunit 19 Gen. Jnl.-Post Preview

Base Application, Microsoft.Finance.GeneralLedger.Preview

src/Layers/W1/BaseApp/Finance/GeneralLedger/Preview/GenJnlPostPreview.Codeunit.al365 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.GeneralLedger.Preview;using Microsoft.Finance.Dimension;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Foundation.Navigate;using Microsoft.Foundation.NoSeries;using System.Telemetry;using System.Utilities;/// <summary>/// Core preview engine for general journal posting operations with comprehensive simulation and validation capabilities./// Provides posting preview functionality without database commits, enabling validation and analysis before actual posting./// </summary>/// <remarks>/// <para>/// <b>Core Functionality:</b>/// Executes posting procedures in preview mode using temporary records and transaction simulation./// Captures posting results, errors, and entry details for display and validation purposes./// </para>/// <para>/// <b>Integration:</b>/// Works with posting codeunits through event subscription, capturing entries through PostingPreviewEventHandler./// Supports multiple posting scenarios including general journals, sales, purchase, and service documents./// </para>/// <para>/// <b>Extensibility:</b>/// Provides integration events for custom preview logic and specialized entry handling./// Enables custom preview scenarios through event-driven architecture./// </para>/// </remarks>codeunit 19 "Gen. Jnl.-Post Preview"{    trigger OnRun()    var        ErrorMessageMgt: Codeunit "Error Message Management";    begin        HideDialogs := true;        CLEAR(PostingPreviewEventHandler);        Preview(PreviewSubscriber, PreviewRecord);        HideDialogs := false;        LastErrorText := GetLastErrorText();        if not IsSuccess() then            ErrorMessageMgt.LogError(PreviewRecord, LastErrorText, '');        Error('');    end;    var        JournalErrorsMgt: Codeunit "Journal Errors Mgt.";        PostingPreviewEventHandler: Codeunit "Posting Preview Event Handler";        PreviewSubscriber: Variant;        PreviewRecord: Variant;        LastErrorText: Text;        HideDialogs: Boolean;        PreviewModeErr: Label 'Preview mode.';        SubscriberTypeErr: Label 'Invalid Subscriber type. The type must be CODEUNIT.';        RecVarTypeErr: Label 'Invalid RecVar type. The type must be RECORD.';        PreviewExitStateErr: Label 'The posting preview has stopped because of a state that is not valid.';        TelemetryFeatureNameTxt: Label 'Posting Preview on journals and documents', Locked = true;        EventNameTxt: Label 'Posting Preview called', Locked = true;        PreviewCalledForMultipleDocumentsMsg: Label 'You selected multiple documents. Posting Preview is shown for document no. %1 only.', Comment = '%1 = Document No.';    /// <summary>    /// Initiates posting preview for the specified document record using the provided posting codeunit.    /// Executes posting logic in simulation mode without committing database transactions.    /// </summary>    /// <param name="Subscriber">Posting codeunit variant that will execute the posting logic</param>    /// <param name="RecVar">Document record variant to be previewed for posting</param>    procedure Preview(Subscriber: Variant; RecVar: Variant)    var        FeatureTelemetry: Codeunit "Feature Telemetry";    begin        OnBeforeRunPreview(Subscriber, RecVar);        FeatureTelemetry.LogUsage('0000JBO', TelemetryFeatureNameTxt, EventNameTxt);        PreviewStart(Subscriber, RecVar);    end;    [CommitBehavior(CommitBehavior::Error)]    local procedure PreviewStart(Subscriber: Variant; RecVar: Variant)    var        ErrorContextElement: Codeunit "Error Context Element";        ErrorMessageHandler: Codeunit "Error Message Handler";        ErrorMessageMgt: Codeunit "Error Message Management";        SequenceNoMgt: Codeunit "Sequence No. Mgt.";        RunResult: Boolean;    begin        if not Subscriber.IsCodeunit then            Error(SubscriberTypeErr);        if not RecVar.IsRecord then            Error(RecVarTypeErr);        BindSubscription(PostingPreviewEventHandler);        ErrorMessageMgt.Activate(ErrorMessageHandler);        ErrorMessageMgt.PushContext(ErrorContextElement, RecVar, 0, PreviewModeErr);        OnAfterBindSubscription(PostingPreviewEventHandler);        RunResult := RunPreview(Subscriber, RecVar);        SequenceNoMgt.StopPreviewMode();        UnbindSubscription(PostingPreviewEventHandler);        OnAfterUnbindSubscription();        // The OnRunPreview event expects subscriber following template: Result := <Codeunit>.RUN        // So we assume RunPreview returns FALSE with the error.        // To prevent return FALSE without thrown error we check error call stack.        if RunResult or (GetLastErrorCallstack = '') then            Error(PreviewExitStateErr);        if not HideDialogs then begin            if GetLastErrorText <> PreviewModeErr then                if ErrorMessageHandler.ShowErrors() then                    Error('');            ShowAllEntries();            Error('');        end;    end;    /// <summary>    /// Retrieves the current posting preview event handler instance for external processing.    /// Enables access to captured preview entries and transaction details.    /// </summary>    /// <param name="ResultPostingPreviewEventHandler">Output parameter receiving the active event handler instance</param>    procedure GetPreviewHandler(var ResultPostingPreviewEventHandler: Codeunit "Posting Preview Event Handler")    begin        ResultPostingPreviewEventHandler := PostingPreviewEventHandler;    end;    /// <summary>    /// Determines whether posting preview mode is currently active.    /// Checks both system-level and extension-specific preview activation status.    /// </summary>    /// <returns>True if posting preview is active, false otherwise</returns>    procedure IsActive(): Boolean    var        Result: Boolean;    begin        // The lookup to event subscription system virtual table is the performance killer.        // We call subscriber CU 20 to get active state of posting preview context.        OnSystemSetPostingPreviewActive(Result);        OnAfterIsActive(Result);        exit(Result);    end;    /// <summary>    /// Determines whether the posting preview operation completed successfully.    /// Validates that preview execution finished without posting errors.    /// </summary>    /// <returns>True if preview completed successfully, false if errors occurred</returns>    procedure IsSuccess(): Boolean;    begin        exit(LastErrorText = PreviewModeErr);    end;    local procedure RunPreview(Subscriber: Variant; RecVar: Variant): Boolean    var        Result: Boolean;    begin        OnRunPreview(Result, Subscriber, RecVar);        exit(Result);    end;    /// <summary>    /// Sets the context for posting preview operations with the specified posting codeunit and record.    /// Configures preview environment for later execution without immediate preview processing.    /// </summary>    /// <param name="Subscriber">Posting codeunit variant that will handle the posting operation</param>    /// <param name="RecVar">Document record variant to be processed in preview mode</param>    procedure SetContext(Subscriber: Variant; RecVar: Variant)    begin        PreviewSubscriber := Subscriber;        PreviewRecord := RecVar;    end;    local procedure ShowAllEntries()    var        GLSetup: Record "General Ledger Setup";        TempDocumentEntry: Record "Document Entry" temporary;        GLPostingPreview: Page "G/L Posting Preview";        ExtendedGLPostingPreview: Page "Extended G/L Posting Preview";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeShowAllEntries(TempDocumentEntry, IsHandled, PostingPreviewEventHandler);        if IsHandled then            exit;        PostingPreviewEventHandler.FillDocumentEntry(TempDocumentEntry);        if not TempDocumentEntry.IsEmpty() then begin            GLSetup.Get();            case GLSetup."Posting Preview Type" of                Enum::"Posting Preview Type"::Standard:                    begin                        GLPostingPreview.Set(TempDocumentEntry, PostingPreviewEventHandler);                        GLPostingPreview.Run();                    end;                Enum::"Posting Preview Type"::Extended:                    begin                        ExtendedGLPostingPreview.Set(TempDocumentEntry, PostingPreviewEventHandler);                        ExtendedGLPostingPreview.Run();                    end;                else                    OnShowAllEntriesOnCaseElse(TempDocumentEntry, PostingPreviewEventHandler);            end;        end else            Message(JournalErrorsMgt.GetNothingToPostErrorMsg());        OnAfterShowAllEntries();    end;    /// <summary>    /// Displays dimension information for a specific entry during posting preview operations.    /// Shows dimension set details associated with preview entries for validation and analysis.    /// </summary>    /// <param name="TableID">Table identifier for the entry type</param>    /// <param name="EntryNo">Entry number for caption display</param>    /// <param name="DimensionSetID">Dimension set identifier to display</param>    procedure ShowDimensions(TableID: Integer; EntryNo: Integer; DimensionSetID: Integer)    var        DimMgt: Codeunit DimensionManagement;        RecRef: RecordRef;    begin        RecRef.Open(TableID);        DimMgt.ShowDimensionSet(DimensionSetID, StrSubstNo('%1 %2', RecRef.Caption, EntryNo));    end;    /// <summary>    /// Triggers the preview mode error to exit posting preview operations gracefully.    /// Used to terminate preview processing and return to normal application flow.    /// </summary>    procedure ThrowError()    begin        OnBeforeThrowError();        Error(PreviewModeErr);    end;    /// <summary>    /// Displays a message when posting preview is requested for multiple documents.    /// Informs users that preview will only show results for the first document in the selection.    /// </summary>    /// <param name="RecordRefToPreview">Record reference containing multiple documents</param>    /// <param name="DocumentNo">Document number that will be previewed</param>    procedure MessageIfPostingPreviewMultipleDocuments(RecordRefToPreview: RecordRef; DocumentNo: Code[20])    begin        if not GuiAllowed() then            exit;        if RecordRefToPreview.Count() <= 1 then            exit;        Message(PreviewCalledForMultipleDocumentsMsg, DocumentNo);    end;    /// <summary>    /// Integration event raised before executing posting preview operations.    /// Enables custom preprocessing or validation before preview execution begins.    /// </summary>    /// <param name="Subscriber">Posting codeunit variant that will handle the preview operation</param>    /// <param name="RecVar">Document record variant to be previewed</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeRunPreview(Subscriber: Variant; RecVar: Variant)    begin    end;    /// <summary>    /// Integration event raised to execute the actual posting preview operation.    /// Allows custom posting codeunits to participate in the preview execution workflow.    /// </summary>    /// <param name="Result">Output parameter indicating whether the preview execution was successful</param>    /// <param name="Subscriber">Posting codeunit variant that will execute the posting logic</param>    /// <param name="RecVar">Document record variant to be processed in preview mode</param>    [IntegrationEvent(false, false)]    local procedure OnRunPreview(var Result: Boolean; Subscriber: Variant; RecVar: Variant)    begin    end;    /// <summary>    /// Integration event raised after binding the posting preview event handler subscription.    /// Enables custom initialization or configuration of the preview event handler.    /// </summary>    /// <param name="PostingPreviewEventHandler">The event handler instance that was bound for preview processing</param>    [IntegrationEvent(false, false)]    local procedure OnAfterBindSubscription(var PostingPreviewEventHandler: Codeunit "Posting Preview Event Handler")    begin    end;    /// <summary>    /// Integration event raised after unbinding the posting preview event handler subscription.    /// Enables custom cleanup or finalization after preview processing completes.    /// </summary>    [IntegrationEvent(false, false)]    local procedure OnAfterUnbindSubscription()    begin    end;    /// <summary>    /// Integration event raised to determine if posting preview mode is active at system level.    /// Allows extensions to indicate whether preview operations should be enabled.    /// </summary>    /// <param name="Result">Output parameter indicating whether posting preview is active</param>    [IntegrationEvent(false, false)]    local procedure OnSystemSetPostingPreviewActive(var Result: Boolean)    begin    end;    /// <summary>    /// Integration event raised after checking if posting preview is active.    /// Enables extensions to modify the active state determination logic.    /// </summary>    /// <param name="Result">Current result of preview active status check, can be modified</param>    [IntegrationEvent(false, false)]    local procedure OnAfterIsActive(var Result: Boolean)    begin    end;    /// <summary>    /// Integration event raised before displaying all preview entries to the user.    /// Enables custom entry filtering, modification, or alternative display handling.    /// </summary>    /// <param name="TempDocumentEntry">Temporary document entry records to be displayed</param>    /// <param name="IsHandled">Set to true to skip standard entry display processing</param>    /// <param name="PostingPreviewEventHandler">Event handler containing captured preview entries</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeShowAllEntries(var TempDocumentEntry: Record "Document Entry" temporary; var IsHandled: Boolean; var PostingPreviewEventHandler: Codeunit "Posting Preview Event Handler")    begin    end;    /// <summary>    /// Integration event raised before throwing the preview mode error to exit gracefully.    /// Enables custom cleanup or finalization before preview termination.    /// </summary>    [IntegrationEvent(false, false)]    local procedure OnBeforeThrowError()    begin    end;    /// <summary>    /// Integration event raised after displaying all preview entries to the user.    /// Enables custom post-display processing or additional user interactions.    /// </summary>    [IntegrationEvent(false, false)]    local procedure OnAfterShowAllEntries()    begin    end;    /// <summary>    /// Integration event raised when no standard preview type matches the configuration.    /// Enables custom preview display handling for extended preview scenarios.    /// </summary>    /// <param name="TempDocumentEntry">Temporary document entry records to be displayed</param>    /// <param name="PostingPreviewEventHandler">Event handler containing captured preview entries</param>    [IntegrationEvent(false, false)]    local procedure OnShowAllEntriesOnCaseElse(var TempDocumentEntry: Record "Document Entry" temporary; var PostingPreviewEventHandler: Codeunit "Posting Preview Event Handler")    begin    end;}