Codeunit 410 Update Analysis View

Base Application, Microsoft.Finance.Analysis

src/Layers/W1/BaseApp/Finance/Analysis/UpdateAnalysisView.Codeunit.al1,033 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.Analysis;using Microsoft.CashFlow.Forecast;using Microsoft.Finance.Dimension;using Microsoft.Finance.GeneralLedger.Budget;using Microsoft.Finance.GeneralLedger.Ledger;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Foundation.Period;using System.Reflection;/// <summary>/// Updates analysis view entries from G/L entries, cash flow entries, and budget entries./// Provides the core engine for maintaining analysis view data with optimized batch processing./// </summary>/// <remarks>/// Central processing codeunit for analysis view maintenance. Handles incremental updates from transaction data,/// manages dimension aggregation, and maintains analysis view entry records. Supports both manual and automatic/// updates triggered by posting routines. Includes progress tracking and error handling for large data volumes./// Extensibility: Multiple integration events for custom processing logic and data validation./// </remarks>codeunit 410 "Update Analysis View"{    Permissions = TableData "G/L Entry" = r,                  TableData "G/L Budget Entry" = r,                  TableData "Analysis View" = rm,                  TableData "Analysis View Filter" = r,                  TableData "Analysis View Entry" = rimd,                  TableData "Analysis View Budget Entry" = rimd;    TableNo = "Analysis View";    trigger OnRun()    begin        if Rec.Code <> '' then begin            InitLastEntryNo();            Rec.LockTable();            Rec.Find();            UpdateOne(Rec, 2, Rec."Last Entry No." < LastGLEntryNo - 1000);        end;    end;    var        AnalysisView: Record "Analysis View";        GLSetup: Record "General Ledger Setup";        GLEntry: Record "G/L Entry";        CFForecastEntry: Record "Cash Flow Forecast Entry";        GLBudgetEntry: Record "G/L Budget Entry";        AnalysisViewEntry: Record "Analysis View Entry";        AnalysisViewFilter: Record "Analysis View Filter";        AnalysisViewBudgetEntry: Record "Analysis View Budget Entry";        TempAnalysisViewEntry: Record "Analysis View Entry" temporary;        TempAnalysisViewBudgetEntry: Record "Analysis View Budget Entry" temporary;        TempDimBuf: Record "Dimension Buffer" temporary;        DimSetEntry: Record "Dimension Set Entry";        TempDimSetEntry: Record "Dimension Set Entry" temporary;        TempDimEntryBuffer: Record "Dimension Entry Buffer" temporary;        Window: Dialog;        FilterIsInitialized: Boolean;        FiltersExist: Boolean;        PrevPostingDate: Date;        PrevCalculatedPostingDate: Date;        NoOfEntries: Integer;        ShowProgressWindow: Boolean;        WinLastEntryNo: Integer;        WinUpdateCounter: Integer;        WinTotalCounter: Integer;        WinTime0: Time;        WinTime1: Time;        WinTime2: Time;        LastGLEntryNo: Integer;        LastBudgetEntryNo: Integer;        LastEntryNoIsInitialized: Boolean;#pragma warning disable AA0074#pragma warning disable AA0470        Text005: Label 'Analysis View     #1############################\\';        Text006: Label 'Updating table    #2############################\';        Text007: Label 'Speed: (Entries/s)#4########\';        Text008: Label 'Average Speed     #5########';        Text009: Label '#6############### @3@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\';#pragma warning restore AA0470        Text010: Label 'Summarizing';        Text011: Label 'Updating Database';#pragma warning restore AA0074        AccountSourceNotSupportedErr: Label 'The selected account source is not supported.';    local procedure InitLastEntryNo()    begin        GLEntry.Reset();        GLBudgetEntry.Reset();        if LastEntryNoIsInitialized then            exit;        LastGLEntryNo := GLEntry.GetLastEntryNo();        LastBudgetEntryNo := GLBudgetEntry.GetLastEntryNo();        LastEntryNoIsInitialized := true;        OnAfterInitLastEntryNo(LastGLEntryNo);    end;    /// <summary>    /// Updates all analysis views that require updating based on specified entry types.    /// </summary>    /// <param name="Which">Type of entries to update (Ledger Entries, Budget Entries, or Both)</param>    /// <param name="DirectlyFromPosting">Whether the update is triggered directly from posting routines</param>    procedure UpdateAll(Which: Option "Ledger Entries","Budget Entries",Both; DirectlyFromPosting: Boolean)    var        AnalysisView2: Record "Analysis View";        InBatchPosting: Boolean;        SessionNo: Integer;    begin        OnBeforeUpdateAll(Which, DirectlyFromPosting, AnalysisView2, InBatchPosting);        if DirectlyFromPosting and InBatchPosting then            exit;        AnalysisView2.ReadIsolation(IsolationLevel::ReadUncommitted);        AnalysisView2.SetRange(Blocked, false);        if DirectlyFromPosting then            AnalysisView2.SetRange("Update on Posting", true);        if AnalysisView2.IsEmpty() then            exit;        if GuiAllowed() and DirectlyFromPosting and TaskScheduler.CanCreateTask() then            StartSession(SessionNo, Codeunit::"Update Analysis View Backgr.")        else            UpdateAll(AnalysisView2, Which, DirectlyFromPosting);    end;    internal procedure UpdateAll(var AnalysisView2: Record "Analysis View"; Which: Option "Ledger Entries","Budget Entries",Both; DirectlyFromPosting: Boolean)    begin        if not AnalysisView2.WritePermission() then            exit;        InitLastEntryNo();        if DirectlyFromPosting then            AnalysisView2.SetFilter("Last Entry No.", '<%1', LastGLEntryNo);        OnUpdateAllOnAfterFilterAnalysisView2(AnalysisView2, DirectlyFromPosting, LastBudgetEntryNo);        AnalysisView2.LockTable();        if AnalysisView2.FindSet() then            repeat                UpdateOne(AnalysisView2, Which, not DirectlyFromPosting and (AnalysisView2."Last Entry No." < LastGLEntryNo - 1000));            until AnalysisView2.Next() = 0;        OnAfterUpdateAll(Which, DirectlyFromPosting);    end;    /// <summary>    /// Updates a single analysis view with data from the specified entry types.    /// </summary>    /// <param name="NewAnalysisView">Analysis view record to update</param>    /// <param name="Which">Type of entries to update (Ledger Entries, Budget Entries, or Both)</param>    /// <param name="ShowWindow">Whether to display progress window during update</param>    procedure Update(var NewAnalysisView: Record "Analysis View"; Which: Option "Ledger Entries","Budget Entries",Both; ShowWindow: Boolean)    begin        InitLastEntryNo();        NewAnalysisView.LockTable();        NewAnalysisView.Find();        UpdateOne(NewAnalysisView, Which, ShowWindow);    end;    local procedure UpdateOne(var NewAnalysisView: Record "Analysis View"; Which: Option "Ledger Entries","Budget Entries",Both; ShowWindow: Boolean)    var        Updated: Boolean;        IsHandled: Boolean;        TableID: Integer;        LastReportedEntryNo: Integer;        Supported: Boolean;    begin        IsHandled := false;        OnBeforeUpdateOne(NewAnalysisView, Which, ShowWindow, IsHandled);        if IsHandled then            exit;        AnalysisView := NewAnalysisView;        AnalysisView.TestField(Blocked, false);        ShowProgressWindow := ShowWindow and GuiAllowed;        if ShowProgressWindow then            InitWindow();        OnUpdateOneOnBeforeUpdateEntries(AnalysisView, Which, LastBudgetEntryNo);        case AnalysisView."Account Source" of            AnalysisView."Account Source"::"G/L Account":                if Which in [Which::"Ledger Entries", Which::Both] then                    if LastGLEntryNo > AnalysisView."Last Entry No." then begin                        if ShowProgressWindow then                            UpdateWindowHeader(DATABASE::"Analysis View Entry", GLEntry."Entry No.");                        UpdateEntries();                        AnalysisView."Last Entry No." := LastGLEntryNo;                        Updated := true;                    end;            AnalysisView."Account Source"::"Cash Flow Account":                begin                    CFForecastEntry.Reset();                    CFForecastEntry.LockTable();                    if ShowProgressWindow then                        UpdateWindowHeader(DATABASE::"Analysis View Entry", CFForecastEntry."Entry No.");                    UpdateEntries();                    Updated := true;                end;            else begin                OnBeforeUpdateOneUpdateEntries(AnalysisView, Which, LastReportedEntryNo, TableID, Supported);                if not Supported then                    Error(AccountSourceNotSupportedErr);                if ShowProgressWindow then                    UpdateWindowHeader(TableID, LastReportedEntryNo);                UpdateEntries();                Updated := true;            end;        end;        OnUpdateOneOnBeforeNewAnalysisViewIncludeBudgetsCheck(NewAnalysisView, AnalysisView, Which);        if (Which in [Which::"Budget Entries", Which::Both]) and           NewAnalysisView."Include Budgets"        then            if LastBudgetEntryNo > AnalysisView."Last Budget Entry No." then begin                if ShowProgressWindow then                    UpdateWindowHeader(DATABASE::"Analysis View Budget Entry", GLBudgetEntry."Entry No.");                GLBudgetEntry.Reset();                GLBudgetEntry.SetRange("Entry No.", AnalysisView."Last Budget Entry No." + 1, LastBudgetEntryNo);                UpdateBudgetEntries(AnalysisView."Last Budget Entry No." + 1);                AnalysisView."Last Budget Entry No." := LastBudgetEntryNo;                Updated := true;            end;        OnUpdateOneOnBeforeUpdateAnalysisView(AnalysisView, TempAnalysisViewEntry, Updated, ShowProgressWindow);        if Updated then begin            AnalysisView."Last Date Updated" := Today;            AnalysisView."Reset Needed" := false;            AnalysisView.Modify();        end;        if ShowProgressWindow then            Window.Close();    end;    local procedure UpdateEntries()    var        UpdAnalysisViewEntryBuffer: Record "Upd Analysis View Entry Buffer";    begin        GLSetup.Get();        FilterIsInitialized := false;        case AnalysisView."Account Source" of            AnalysisView."Account Source"::"G/L Account":                UpdateEntriesForGLAccount();            AnalysisView."Account Source"::"Cash Flow Account":                UpdateEntriesForCFAccount();        end;        OnGetEntriesForUpdate(AnalysisView, UpdAnalysisViewEntryBuffer);        UpdAnalysisViewEntryBuffer.Reset();        if UpdAnalysisViewEntryBuffer.FindSet() then            repeat                UpdateAnalysisViewEntry(UpdAnalysisViewEntryBuffer);            until UpdAnalysisViewEntryBuffer.Next() = 0;        FlushAnalysisViewEntry();    end;    local procedure UpdateEntriesForGLAccount()    var        AnalysisViewGLQry: Query "Analysis View Source";        EntryNo: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateEntriesForGLAccount(TempAnalysisViewEntry, AnalysisView, LastGLEntryNo, NoOfEntries, IsHandled, ShowProgressWindow);        if IsHandled then            exit;        if AnalysisView."Date Compression" = AnalysisView."Date Compression"::None then begin            UpdateEntriesForGLAccountDetailed();            exit;        end;        AnalysisViewGLQry.SetRange(AnalysisViewCode, AnalysisView.Code);        AnalysisViewGLQry.SetRange(EntryNo, AnalysisView."Last Entry No." + 1, LastGLEntryNo);        if AnalysisView."Account Filter" = '' then            AnalysisViewGLQry.SetFilter(GLAccNo, '>%1', '')        else            AnalysisViewGLQry.SetFilter(GLAccNo, AnalysisView."Account Filter");        if AnalysisView."Business Unit Filter" <> '' then            AnalysisViewGLQry.SetFilter(BusinessUnitCode, AnalysisView."Business Unit Filter");        OnUpdateEntriesForGLAccountOnAfterAnalysisViewGLQrySetFilters(AnalysisViewGLQry, AnalysisView);        AnalysisViewGLQry.Open();        while AnalysisViewGLQry.Read() do begin            if DimSetIDInFilter(AnalysisViewGLQry.DimensionSetID, AnalysisView) then                UpdateAnalysisViewEntry(                  AnalysisViewGLQry.GLAccNo,                  AnalysisViewGLQry.BusinessUnitCode,                  '',                  AnalysisViewGLQry.DimVal1,                  AnalysisViewGLQry.DimVal2,                  AnalysisViewGLQry.DimVal3,                  AnalysisViewGLQry.DimVal4,                  AnalysisViewGLQry.PostingDate,                  AnalysisViewGLQry.Amount,                  AnalysisViewGLQry.DebitAmount,                  AnalysisViewGLQry.CreditAmount,                  AnalysisViewGLQry.AmountACY,                  AnalysisViewGLQry.DebitAmountACY,                  AnalysisViewGLQry.CreditAmountACY,                  0);            EntryNo := EntryNo + 1;            if ShowProgressWindow then                UpdateWindowCounter(EntryNo);        end;        AnalysisViewGLQry.Close();    end;    local procedure UpdateEntriesForGLAccountDetailed()    var        GLEntry: Record "G/L Entry";        EntryNo: Integer;    begin        GLEntry.SetRange("Entry No.", AnalysisView."Last Entry No." + 1, LastGLEntryNo);        if AnalysisView."Account Filter" <> '' then            GLEntry.SetFilter("G/L Account No.", AnalysisView."Account Filter");        if AnalysisView."Business Unit Filter" <> '' then            GLEntry.SetFilter("Business Unit Code", AnalysisView."Business Unit Filter");        OnUpdateEntriesForGLAccountDetailedOnAfterGLEntrySetFilters(GLEntry, AnalysisView);        if GLEntry.FindSet() then            repeat                if DimSetIDInFilter(GLEntry."Dimension Set ID", AnalysisView) then                    UpdateAnalysisViewEntry(                      GLEntry."G/L Account No.", GLEntry."Business Unit Code", '',                      GetDimVal(AnalysisView."Dimension 1 Code", GLEntry."Dimension Set ID"),                      GetDimVal(AnalysisView."Dimension 2 Code", GLEntry."Dimension Set ID"),                      GetDimVal(AnalysisView."Dimension 3 Code", GLEntry."Dimension Set ID"),                      GetDimVal(AnalysisView."Dimension 4 Code", GLEntry."Dimension Set ID"),                      GLEntry."Posting Date", GLEntry.Amount, GLEntry."Debit Amount", GLEntry."Credit Amount",                      GLEntry."Additional-Currency Amount", GLEntry."Add.-Currency Debit Amount", GLEntry."Add.-Currency Credit Amount", GLEntry."Entry No.");                EntryNo := EntryNo + 1;                if ShowProgressWindow then                    UpdateWindowCounter(EntryNo);            until GLEntry.Next() = 0;    end;    local procedure UpdateEntriesForCFAccount()    begin        AnalysisViewEntry.SetRange("Analysis View Code", AnalysisView.Code);        AnalysisViewEntry.DeleteAll();        AnalysisViewEntry.Reset();        CFForecastEntry.FilterGroup(2);        CFForecastEntry.SetFilter("Cash Flow Account No.", '<>%1', '');        CFForecastEntry.FilterGroup(0);        if AnalysisView."Account Filter" <> '' then            CFForecastEntry.SetFilter("Cash Flow Account No.", AnalysisView."Account Filter");        if GLSetup."Global Dimension 1 Code" <> '' then            if AnalysisViewFilter.Get(AnalysisView.Code, GLSetup."Global Dimension 1 Code") then                if AnalysisViewFilter."Dimension Value Filter" <> '' then                    CFForecastEntry.SetFilter("Global Dimension 1 Code", AnalysisViewFilter."Dimension Value Filter");        if GLSetup."Global Dimension 2 Code" <> '' then            if AnalysisViewFilter.Get(AnalysisView.Code, GLSetup."Global Dimension 2 Code") then                if AnalysisViewFilter."Dimension Value Filter" <> '' then                    CFForecastEntry.SetFilter("Global Dimension 2 Code", AnalysisViewFilter."Dimension Value Filter");        if not CFForecastEntry.Find('-') then            exit;        repeat            if DimSetIDInFilter(CFForecastEntry."Dimension Set ID", AnalysisView) then                UpdateAnalysisViewEntry(                  CFForecastEntry."Cash Flow Account No.",                  '',                  CFForecastEntry."Cash Flow Forecast No.",                  GetDimVal(AnalysisView."Dimension 1 Code", CFForecastEntry."Dimension Set ID"),                  GetDimVal(AnalysisView."Dimension 2 Code", CFForecastEntry."Dimension Set ID"),                  GetDimVal(AnalysisView."Dimension 3 Code", CFForecastEntry."Dimension Set ID"),                  GetDimVal(AnalysisView."Dimension 4 Code", CFForecastEntry."Dimension Set ID"),                  CFForecastEntry."Cash Flow Date",                  CFForecastEntry."Amount (LCY)",                  0, 0, 0, 0, 0,                  CFForecastEntry."Entry No.");            if ShowProgressWindow then                UpdateWindowCounter(CFForecastEntry."Entry No.");        until CFForecastEntry.Next() = 0;        if ShowProgressWindow then            UpdateWindowCounter(CFForecastEntry."Entry No.");    end;    local procedure UpdateBudgetEntries(DeleteFromEntry: Integer)    begin        AnalysisViewBudgetEntry.SetRange("Analysis View Code", AnalysisView.Code);        AnalysisViewBudgetEntry.SetFilter("Entry No.", '>=%1', DeleteFromEntry);        AnalysisViewBudgetEntry.DeleteAll();        AnalysisViewBudgetEntry.Reset();        if AnalysisView."Account Filter" <> '' then            GLBudgetEntry.SetFilter("G/L Account No.", AnalysisView."Account Filter");        if AnalysisView."Business Unit Filter" <> '' then            GLBudgetEntry.SetFilter("Business Unit Code", AnalysisView."Business Unit Filter");        OnUpdateBudgetEntriesOnAfterGLBudgetEntrySetFilters(GLBudgetEntry, AnalysisView);        if not GLBudgetEntry.FindSet(true) then            exit;        repeat            if DimSetIDInFilter(GLBudgetEntry."Dimension Set ID", AnalysisView) then                UpdateAnalysisViewBudgetEntry(                  GetDimVal(AnalysisView."Dimension 1 Code", GLBudgetEntry."Dimension Set ID"),                  GetDimVal(AnalysisView."Dimension 2 Code", GLBudgetEntry."Dimension Set ID"),                  GetDimVal(AnalysisView."Dimension 3 Code", GLBudgetEntry."Dimension Set ID"),                  GetDimVal(AnalysisView."Dimension 4 Code", GLBudgetEntry."Dimension Set ID"));            if ShowProgressWindow then                UpdateWindowCounter(GLBudgetEntry."Entry No.");        until GLBudgetEntry.Next() = 0;        if ShowProgressWindow then            UpdateWindowCounter(GLBudgetEntry."Entry No.");        FlushAnalysisViewBudgetEntry();    end;    /// <summary>    /// Updates analysis view entry with individual transaction data from G/L or Cash Flow entries.    /// Stages transaction data in buffer for aggregation into final analysis view entries.    /// </summary>    /// <param name="AccNo">Account number (G/L Account or Cash Flow Account)</param>    /// <param name="BusUnitCode">Business unit code for consolidation scenarios</param>    /// <param name="CashFlowForecastNo">Cash flow forecast number for cash flow entries</param>    /// <param name="DimValue1">Dimension 1 value code from source transaction</param>    /// <param name="DimValue2">Dimension 2 value code from source transaction</param>    /// <param name="DimValue3">Dimension 3 value code from source transaction</param>    /// <param name="DimValue4">Dimension 4 value code from source transaction</param>    /// <param name="PostingDate">Posting date from source transaction</param>    /// <param name="Amount">Net amount in local currency</param>    /// <param name="DebitAmount">Debit amount in local currency</param>    /// <param name="CreditAmount">Credit amount in local currency</param>    /// <param name="AmountACY">Net amount in additional currency</param>    /// <param name="DebitAmountACY">Debit amount in additional currency</param>    /// <param name="CreditAmountACY">Credit amount in additional currency</param>    /// <param name="EntryNo">Entry number from source transaction for traceability</param>    procedure UpdateAnalysisViewEntry(AccNo: Code[20]; BusUnitCode: Code[20]; CashFlowForecastNo: Code[20]; DimValue1: Code[20]; DimValue2: Code[20]; DimValue3: Code[20]; DimValue4: Code[20]; PostingDate: Date; Amount: Decimal; DebitAmount: Decimal; CreditAmount: Decimal; AmountACY: Decimal; DebitAmountACY: Decimal; CreditAmountACY: Decimal; EntryNo: Integer)    var        UpdAnalysisViewEntryBuffer: Record "Upd Analysis View Entry Buffer";    begin        UpdAnalysisViewEntryBuffer.AccNo := AccNo;        UpdAnalysisViewEntryBuffer.BusUnitCode := BusUnitCode;        UpdAnalysisViewEntryBuffer.CashFlowForecastNo := CashFlowForecastNo;        UpdAnalysisViewEntryBuffer.DimValue1 := DimValue1;        UpdAnalysisViewEntryBuffer.DimValue2 := DimValue2;        UpdAnalysisViewEntryBuffer.DimValue3 := DimValue3;        UpdAnalysisViewEntryBuffer.DimValue4 := DimValue4;        UpdAnalysisViewEntryBuffer.PostingDate := PostingDate;        UpdAnalysisViewEntryBuffer.Amount := Amount;        UpdAnalysisViewEntryBuffer.DebitAmount := DebitAmount;        UpdAnalysisViewEntryBuffer.CreditAmount := CreditAmount;        UpdAnalysisViewEntryBuffer.AmountACY := AmountACY;        UpdAnalysisViewEntryBuffer.DebitAmountACY := DebitAmountACY;        UpdAnalysisViewEntryBuffer.CreditAmountACY := CreditAmountACY;        UpdAnalysisViewEntryBuffer.EntryNo := EntryNo;        UpdAnalysisViewEntryBuffer.Insert();        UpdateAnalysisViewEntry(UpdAnalysisViewEntryBuffer);    end;    /// <summary>    /// Updates analysis view entry using buffer record with date compression and aggregation logic.    /// Processes buffer data with period start calculation and dimension aggregation rules.    /// </summary>    /// <param name="UpdAnalysisViewEntryBuffer">Buffer record containing staged transaction data for processing</param>    procedure UpdateAnalysisViewEntry(UpdAnalysisViewEntryBuffer: Record "Upd Analysis View Entry Buffer")    var        DummyUpdAnalysisViewEntryBuffer: Record "Upd Analysis View Entry Buffer";    begin        if UpdAnalysisViewEntryBuffer.PostingDate < AnalysisView."Starting Date" then begin            UpdAnalysisViewEntryBuffer.PostingDate := AnalysisView."Starting Date" - 1;            if AnalysisView."Date Compression" <> AnalysisView."Date Compression"::None then                UpdAnalysisViewEntryBuffer.EntryNo := 0;        end else begin            UpdAnalysisViewEntryBuffer.PostingDate := CalculatePeriodStart(UpdAnalysisViewEntryBuffer.PostingDate, AnalysisView."Date Compression");            if UpdAnalysisViewEntryBuffer.PostingDate < AnalysisView."Starting Date" then                UpdAnalysisViewEntryBuffer.PostingDate := AnalysisView."Starting Date";            if AnalysisView."Date Compression" <> AnalysisView."Date Compression"::None then                UpdAnalysisViewEntryBuffer.EntryNo := 0;        end;        TempAnalysisViewEntry."Analysis View Code" := AnalysisView.Code;        if UpdAnalysisViewEntryBuffer."Account Source" = DummyUpdAnalysisViewEntryBuffer."Account Source" then            UpdAnalysisViewEntryBuffer."Account Source" := AnalysisView."Account Source";        TempAnalysisViewEntry."Account Source" := UpdAnalysisViewEntryBuffer."Account Source";        TempAnalysisViewEntry."Business Unit Code" := UpdAnalysisViewEntryBuffer.BusUnitCode;        TempAnalysisViewEntry."Account No." := UpdAnalysisViewEntryBuffer.AccNo;        TempAnalysisViewEntry."Cash Flow Forecast No." := UpdAnalysisViewEntryBuffer.CashFlowForecastNo;        TempAnalysisViewEntry."Posting Date" := UpdAnalysisViewEntryBuffer.PostingDate;        TempAnalysisViewEntry."Dimension 1 Value Code" := UpdAnalysisViewEntryBuffer.DimValue1;        TempAnalysisViewEntry."Dimension 2 Value Code" := UpdAnalysisViewEntryBuffer.DimValue2;        TempAnalysisViewEntry."Dimension 3 Value Code" := UpdAnalysisViewEntryBuffer.DimValue3;        TempAnalysisViewEntry."Dimension 4 Value Code" := UpdAnalysisViewEntryBuffer.DimValue4;        TempAnalysisViewEntry."Entry No." := UpdAnalysisViewEntryBuffer.EntryNo;        OnUpdateAnalysisViewEntryOnAfterTempAnalysisViewEntryAssignment(TempAnalysisViewEntry, AnalysisView, GLEntry, UpdAnalysisViewEntryBuffer);        if TempAnalysisViewEntry.Find() then begin            TempAnalysisViewEntry.Amount += UpdAnalysisViewEntryBuffer.Amount;            TempAnalysisViewEntry."Debit Amount" += UpdAnalysisViewEntryBuffer.DebitAmount;            TempAnalysisViewEntry."Credit Amount" += UpdAnalysisViewEntryBuffer.CreditAmount;            TempAnalysisViewEntry."Add.-Curr. Amount" += UpdAnalysisViewEntryBuffer.AmountACY;            TempAnalysisViewEntry."Add.-Curr. Debit Amount" += UpdAnalysisViewEntryBuffer.DebitAmountACY;            TempAnalysisViewEntry."Add.-Curr. Credit Amount" += UpdAnalysisViewEntryBuffer.CreditAmountACY;            TempAnalysisViewEntry.Modify();        end else begin            TempAnalysisViewEntry.Amount := UpdAnalysisViewEntryBuffer.Amount;            TempAnalysisViewEntry."Debit Amount" := UpdAnalysisViewEntryBuffer.DebitAmount;            TempAnalysisViewEntry."Credit Amount" := UpdAnalysisViewEntryBuffer.CreditAmount;            TempAnalysisViewEntry."Add.-Curr. Amount" := UpdAnalysisViewEntryBuffer.AmountACY;            TempAnalysisViewEntry."Add.-Curr. Debit Amount" := UpdAnalysisViewEntryBuffer.DebitAmountACY;            TempAnalysisViewEntry."Add.-Curr. Credit Amount" := UpdAnalysisViewEntryBuffer.CreditAmountACY;            TempAnalysisViewEntry.Insert();            NoOfEntries := NoOfEntries + 1;        end;        if NoOfEntries >= 10000 then            FlushAnalysisViewEntry();    end;    local procedure UpdateAnalysisViewBudgetEntry(DimValue1: Code[20]; DimValue2: Code[20]; DimValue3: Code[20]; DimValue4: Code[20])    begin        TempAnalysisViewBudgetEntry."Analysis View Code" := AnalysisView.Code;        TempAnalysisViewBudgetEntry."Budget Name" := GLBudgetEntry."Budget Name";        TempAnalysisViewBudgetEntry."Business Unit Code" := GLBudgetEntry."Business Unit Code";        TempAnalysisViewBudgetEntry."G/L Account No." := GLBudgetEntry."G/L Account No.";        if GLBudgetEntry.Date < AnalysisView."Starting Date" then            TempAnalysisViewBudgetEntry."Posting Date" := AnalysisView."Starting Date" - 1        else begin            TempAnalysisViewBudgetEntry."Posting Date" :=              CalculatePeriodStart(GLBudgetEntry.Date, AnalysisView."Date Compression");            if TempAnalysisViewBudgetEntry."Posting Date" < AnalysisView."Starting Date" then                TempAnalysisViewBudgetEntry."Posting Date" := AnalysisView."Starting Date";        end;        TempAnalysisViewBudgetEntry."Dimension 1 Value Code" := DimValue1;        TempAnalysisViewBudgetEntry."Dimension 2 Value Code" := DimValue2;        TempAnalysisViewBudgetEntry."Dimension 3 Value Code" := DimValue3;        TempAnalysisViewBudgetEntry."Dimension 4 Value Code" := DimValue4;        TempAnalysisViewBudgetEntry."Entry No." := GLBudgetEntry."Entry No.";        OnUpdateAnalysisViewBudgetEntryOnAfterTempAnalysisViewBudgetEntryAssignment(TempAnalysisViewBudgetEntry, AnalysisView, GLBudgetEntry, DimValue1, DimValue2, DimValue3, DimValue4);        if TempAnalysisViewBudgetEntry.Find() then begin            TempAnalysisViewBudgetEntry.Amount := TempAnalysisViewBudgetEntry.Amount + GLBudgetEntry.Amount;            TempAnalysisViewBudgetEntry.Modify();        end else begin            TempAnalysisViewBudgetEntry.Amount := GLBudgetEntry.Amount;            TempAnalysisViewBudgetEntry.Insert();            NoOfEntries := NoOfEntries + 1;        end;        if NoOfEntries >= 10000 then            FlushAnalysisViewBudgetEntry();    end;    /// <summary>    /// Calculates the period start date based on the posting date and date compression setting.    /// Adjusts the date to align with analysis view period boundaries.    /// </summary>    /// <param name="PostingDate">Original posting date to calculate period start for</param>    /// <param name="DateCompression">Date compression option determining period granularity</param>    /// <returns>Calculated period start date aligned with compression settings</returns>    procedure CalculatePeriodStart(PostingDate: Date; DateCompression: Integer): Date    var        AccountingPeriod: Record "Accounting Period";    begin        if PostingDate = ClosingDate(PostingDate) then            exit(PostingDate);        case DateCompression of            AnalysisView."Date Compression"::Week:                PostingDate := CalcDate('<CW+1D-1W>', PostingDate);            AnalysisView."Date Compression"::Month:                PostingDate := CalcDate('<CM+1D-1M>', PostingDate);            AnalysisView."Date Compression"::Quarter:                PostingDate := CalcDate('<CQ+1D-1Q>', PostingDate);            AnalysisView."Date Compression"::Year:                PostingDate := CalcDate('<CY+1D-1Y>', PostingDate);            AnalysisView."Date Compression"::Period:                begin                    if PostingDate <> PrevPostingDate then begin                        PrevPostingDate := PostingDate;                        AccountingPeriod.SetRange("Starting Date", 0D, PostingDate);                        if AccountingPeriod.FindLast() then                            PrevCalculatedPostingDate := AccountingPeriod."Starting Date"                        else                            PrevCalculatedPostingDate := PostingDate;                    end;                    PostingDate := PrevCalculatedPostingDate;                end;        end;        OnAfterCalculatePeriodStart(AnalysisView, DateCompression, AccountingPeriod, PostingDate, PrevCalculatedPostingDate, PrevPostingDate);        exit(PostingDate);    end;    /// <summary>    /// Flushes accumulated analysis view entries from temporary storage to the database.    /// Processes temporary analysis view entries and inserts them as permanent records.    /// </summary>    procedure FlushAnalysisViewEntry()    begin        if ShowProgressWindow then            Window.Update(6, Text011);        if TempAnalysisViewEntry.FindSet() then            repeat                AnalysisViewEntry.Init();                AnalysisViewEntry := TempAnalysisViewEntry;                OnFlushAnalysisViewEntryOnBeforeAnalysisViewEntryInsert(AnalysisViewEntry, TempAnalysisViewEntry);                if not AnalysisViewEntry.Insert() then begin                    AnalysisViewEntry.Find();                    AnalysisViewEntry.Amount += TempAnalysisViewEntry.Amount;                    AnalysisViewEntry."Debit Amount" += TempAnalysisViewEntry."Debit Amount";                    AnalysisViewEntry."Credit Amount" += TempAnalysisViewEntry."Credit Amount";                    AnalysisViewEntry."Add.-Curr. Amount" += TempAnalysisViewEntry."Add.-Curr. Amount";                    AnalysisViewEntry."Add.-Curr. Debit Amount" += TempAnalysisViewEntry."Add.-Curr. Debit Amount";                    AnalysisViewEntry."Add.-Curr. Credit Amount" += TempAnalysisViewEntry."Add.-Curr. Credit Amount";                    AnalysisViewEntry.Modify();                end;            until TempAnalysisViewEntry.Next() = 0;        TempAnalysisViewEntry.DeleteAll();        NoOfEntries := 0;        if ShowProgressWindow then            Window.Update(6, Text010);    end;    /// <summary>    /// Flushes accumulated analysis view budget entries from temporary storage to the database.    /// Processes temporary budget entries and inserts them as permanent records.    /// </summary>    procedure FlushAnalysisViewBudgetEntry()    begin        if ShowProgressWindow then            Window.Update(6, Text011);        if TempAnalysisViewBudgetEntry.FindSet() then            repeat                AnalysisViewBudgetEntry.Init();                AnalysisViewBudgetEntry := TempAnalysisViewBudgetEntry;                if not AnalysisViewBudgetEntry.Insert() then begin                    AnalysisViewBudgetEntry.Find();                    AnalysisViewBudgetEntry.Amount += TempAnalysisViewBudgetEntry.Amount;                    AnalysisViewBudgetEntry.Modify();                end;            until TempAnalysisViewBudgetEntry.Next() = 0;        TempAnalysisViewBudgetEntry.DeleteAll();        NoOfEntries := 0;        if ShowProgressWindow then            Window.Update(6, Text010);    end;    /// <summary>    /// Retrieves dimension value code for a specific dimension from a dimension set.    /// Uses temporary caching to optimize repeated dimension value lookups during analysis view updates.    /// </summary>    /// <param name="DimCode">Dimension code to retrieve value for</param>    /// <param name="DimSetID">Dimension set ID containing the dimension values</param>    /// <returns>Dimension value code for the specified dimension, empty if not found</returns>    procedure GetDimVal(DimCode: Code[20]; DimSetID: Integer): Code[20]    begin        if TempDimSetEntry.Get(DimSetID, DimCode) then            exit(TempDimSetEntry."Dimension Value Code");        if DimSetEntry.Get(DimSetID, DimCode) then            TempDimSetEntry := DimSetEntry        else begin            TempDimSetEntry."Dimension Set ID" := DimSetID;            TempDimSetEntry."Dimension Code" := DimCode;            TempDimSetEntry."Dimension Value Code" := '';        end;        TempDimSetEntry.Insert();        exit(TempDimSetEntry."Dimension Value Code");    end;    local procedure InitWindow()    begin        Window.Open(          Text005 +          Text006 +          Text009 +          Text007 +          Text008);        Window.Update(6, Text010);    end;    /// <summary>    /// Updates progress window counter during analysis view update operations.    /// Tracks processing progress and updates user interface with percentage completion.    /// </summary>    /// <param name="EntryNo">Current entry number being processed for progress tracking</param>    procedure UpdateWindowCounter(EntryNo: Integer)    begin        WinUpdateCounter := WinUpdateCounter + 1;        WinTime2 := Time;        if (WinTime2 > WinTime1 + 1000) or (EntryNo = WinLastEntryNo) then begin            if WinLastEntryNo <> 0 then                Window.Update(3, Round(EntryNo / WinLastEntryNo * 10000, 1));            WinTotalCounter := WinTotalCounter + WinUpdateCounter;            if WinTime2 <> WinTime1 then                Window.Update(4, Round(WinUpdateCounter * (1000 / (WinTime2 - WinTime1)), 1));            if WinTime2 <> WinTime0 then                Window.Update(5, Round(WinTotalCounter * (1000 / (WinTime2 - WinTime0)), 1));            WinTime1 := WinTime2;            WinUpdateCounter := 0;        end;    end;    /// <summary>    /// Updates progress window header information during analysis view update operations.    /// Displays current table being processed and entry numbers for user feedback.    /// </summary>    /// <param name="TableID">Table ID being processed for display in progress window</param>    /// <param name="EntryNo">Entry number being processed for progress tracking</param>    procedure UpdateWindowHeader(TableID: Integer; EntryNo: Integer)    var        AllObj: Record AllObj;    begin        WinLastEntryNo := EntryNo;        WinTotalCounter := 0;        AllObj.Get(AllObj."Object Type"::Table, TableID);        Window.Update(1, AnalysisView.Code);        Window.Update(2, AllObj."Object Name");        Window.Update(3, 0);        Window.Update(4, 0);        Window.Update(5, 0);        WinTime0 := Time;        WinTime1 := WinTime0;        WinTime2 := WinTime0;    end;    /// <summary>    /// Sets the last budget entry number processed for analysis view updates.    /// Updates the analysis view record with the latest processed budget entry number to track update progress.    /// </summary>    /// <param name="NewLastBudgetEntryNo">New last budget entry number to set for tracking processed entries</param>    procedure SetLastBudgetEntryNo(NewLastBudgetEntryNo: Integer)    var        AnalysisView2: Record "Analysis View";    begin        AnalysisView.SetRange("Last Budget Entry No.", NewLastBudgetEntryNo + 1, 2147483647);        AnalysisView.SetRange("Include Budgets", true);        if AnalysisView.FindSet(true) then            repeat                AnalysisView2 := AnalysisView;                AnalysisView2."Last Budget Entry No." := NewLastBudgetEntryNo;                AnalysisView2.Modify();            until AnalysisView.Next() = 0;    end;    local procedure IsValueIncludedInFilter(DimValue: Code[20]; DimFilter: Code[250]): Boolean    begin        TempDimBuf.Reset();        TempDimBuf.DeleteAll();        TempDimBuf.Init();        TempDimBuf."Dimension Value Code" := DimValue;        TempDimBuf.Insert();        TempDimBuf.SetFilter(TempDimBuf."Dimension Value Code", DimFilter);        exit(TempDimBuf.FindFirst());    end;    /// <summary>    /// Determines whether a dimension set ID matches the analysis view's dimension filters.    /// Validates that all dimension values in the set comply with analysis view filtering criteria.    /// </summary>    /// <param name="DimSetID">Dimension set ID to validate against analysis view filters</param>    /// <param name="AnalysisView">Analysis view record containing dimension filter criteria</param>    /// <returns>True if dimension set matches all analysis view filters, false otherwise</returns>    procedure DimSetIDInFilter(DimSetID: Integer; var AnalysisView: Record "Analysis View"): Boolean    var        InFilters: Boolean;    begin        if not FilterIsInitialized then begin            TempDimEntryBuffer.DeleteAll();            FilterIsInitialized := true;            AnalysisViewFilter.SetRange("Analysis View Code", AnalysisView.Code);            FiltersExist := not AnalysisViewFilter.IsEmpty();        end;        if not FiltersExist then            exit(true);        if TempDimEntryBuffer.Get(DimSetID) then  // cashed value?            exit(TempDimEntryBuffer."Dimension Entry No." <> 0);        InFilters := true;        if AnalysisViewFilter.FindSet() then            repeat                if DimSetEntry.Get(DimSetID, AnalysisViewFilter."Dimension Code") then                    InFilters :=                      InFilters and IsValueIncludedInFilter(DimSetEntry."Dimension Value Code", AnalysisViewFilter."Dimension Value Filter")                else                    InFilters :=                      InFilters and IsValueIncludedInFilter('', AnalysisViewFilter."Dimension Value Filter");            until (AnalysisViewFilter.Next() = 0) or not InFilters;        TempDimEntryBuffer."No." := DimSetID;        if InFilters then            TempDimEntryBuffer."Dimension Entry No." := 1        else            TempDimEntryBuffer."Dimension Entry No." := 0;        TempDimEntryBuffer.Insert();        exit(InFilters);    end;    /// <summary>    /// Integration event raised after initializing last entry number for analysis view updates.    /// Allows modification of the starting entry number for update processing.    /// </summary>    /// <param name="LastGLEntryNo">Last G/L entry number that can be modified by subscribers</param>    [IntegrationEvent(false, false)]    local procedure OnAfterInitLastEntryNo(var LastGLEntryNo: Integer)    begin    end;    /// <summary>    /// Integration event raised after completing analysis view update operations.    /// Enables post-update processing and cleanup activities.    /// </summary>    /// <param name="Which">Update option indicating which entries were processed</param>    /// <param name="DirectlyFromPosting">Indicates whether update was triggered directly from posting</param>    [IntegrationEvent(false, false)]    local procedure OnAfterUpdateAll(Which: Option "Ledger Entries","Budget Entries",Both; DirectlyFromPosting: Boolean)    begin    end;    /// <summary>    /// Integration event raised before starting analysis view update operations.    /// Allows preprocessing and modification of update parameters.    /// </summary>    /// <param name="Which">Update option indicating which entries to process</param>    /// <param name="DirectlyFromPosting">Indicates whether update is triggered directly from posting</param>    /// <param name="AnalysisView">Analysis view record being updated</param>    /// <param name="InBatchPosting">Set to true to indicate batch posting mode</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateAll(Which: Option "Ledger Entries","Budget Entries",Both; DirectlyFromPosting: Boolean; var AnalysisView: Record "Analysis View"; var InBatchPosting: Boolean)    begin    end;    /// <summary>    /// Integration event raised before updating a single analysis view.    /// Allows custom handling and preprocessing for individual analysis view updates.    /// </summary>    /// <param name="NewAnalysisView">Analysis view record to be updated</param>    /// <param name="Which">Update option indicating which entries to process</param>    /// <param name="ShowWindow">Indicates whether to show progress window during update</param>    /// <param name="IsHandled">Set to true to skip standard update processing</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateOne(var NewAnalysisView: Record "Analysis View"; Which: Option "Ledger Entries","Budget Entries",Both; ShowWindow: Boolean; var IsHandled: Boolean)    begin    end;    /// <summary>    /// Integration event raised before updating entries for G/L account analysis views.    /// Allows custom entry processing and modification of update parameters.    /// </summary>    /// <param name="TempAnalysisViewEntry">Temporary analysis view entry records being processed</param>    /// <param name="AnalysisView">Analysis view record controlling the update</param>    /// <param name="LastGLEntryNo">Last G/L entry number to process</param>    /// <param name="NoOfEntries">Number of entries being processed</param>    /// <param name="IsHandled">Set to true to skip standard entry processing</param>    /// <param name="ShowProgressWindow">Indicates whether to show progress window</param>    [IntegrationEvent(true, false)]    local procedure OnBeforeUpdateEntriesForGLAccount(var TempAnalysisViewEntry: Record "Analysis View Entry" temporary; AnalysisView: Record "Analysis View"; LastGLEntryNo: Integer; var NoOfEntries: Integer; var IsHandled: Boolean; ShowProgressWindow: Boolean)    begin    end;    /// <summary>    /// Integration event raised before inserting analysis view entries during flush operations.    /// Allows modification of analysis view entries before they are permanently stored.    /// </summary>    /// <param name="AnalysisViewEntry">Analysis view entry record to be inserted</param>    /// <param name="TempAnalysisViewEntry">Temporary analysis view entry source data</param>    [IntegrationEvent(false, false)]    local procedure OnFlushAnalysisViewEntryOnBeforeAnalysisViewEntryInsert(var AnalysisViewEntry: Record "Analysis View Entry"; TempAnalysisViewEntry: Record "Analysis View Entry" temporary)    begin    end;    /// <summary>    /// Integration event raised before updating analysis view during single view update operations.    /// Allows custom processing and modification of analysis view update parameters.    /// </summary>    /// <param name="AnalysisView">Analysis view record being updated</param>    /// <param name="TempAnalysisViewEntry">Temporary analysis view entry records being processed</param>    /// <param name="Updated">Indicates whether analysis view was updated</param>    /// <param name="ShowProgressWindow">Indicates whether to show progress window</param>    [IntegrationEvent(true, false)]    local procedure OnUpdateOneOnBeforeUpdateAnalysisView(var AnalysisView: Record "Analysis View"; var TempAnalysisViewEntry: Record "Analysis View Entry" temporary; var Updated: Boolean; ShowProgressWindow: Boolean)    begin    end;    /// <summary>    /// Integration event raised before checking if new analysis view includes budgets during update process.    /// Enables custom validation logic for budget inclusion in analysis view updates.    /// </summary>    /// <param name="NewAnalysisView">New analysis view configuration</param>    /// <param name="AnalysisView">Current analysis view being updated</param>    /// <param name="Which">Update type indicating whether to update ledger entries, budget entries, or both</param>    [IntegrationEvent(false, false)]    local procedure OnUpdateOneOnBeforeNewAnalysisViewIncludeBudgetsCheck(var NewAnalysisView: Record "Analysis View"; var AnalysisView: Record "Analysis View"; Which: Option "Ledger Entries","Budget Entries",Both)    begin    end;    /// <summary>    /// Integration event raised before starting analysis view entry updates.    /// Enables custom logic before analysis view entries are processed and updated.    /// </summary>    /// <param name="AnalysisView">Analysis view being updated</param>    /// <param name="Which">Update type indicating whether to update ledger entries, budget entries, or both</param>    /// <param name="LastGLEntryNo">Last G/L entry number processed in the update</param>    [IntegrationEvent(false, false)]    local procedure OnUpdateOneOnBeforeUpdateEntries(var AnalysisView: Record "Analysis View"; Which: Option "Ledger Entries","Budget Entries",Both; LastGLEntryNo: Integer)    begin    end;    /// <summary>    /// Integration event raised after setting filters on G/L Budget Entry during budget update process.    /// Enables additional filtering logic for budget entries being processed.    /// </summary>    /// <param name="GLBudgetEntry">G/L Budget Entry record with applied filters</param>    /// <param name="AnalysisView">Analysis view configuration being updated</param>    [IntegrationEvent(false, false)]    local procedure OnUpdateBudgetEntriesOnAfterGLBudgetEntrySetFilters(var GLBudgetEntry: Record "G/L Budget Entry"; var AnalysisView: Record "Analysis View")    begin    end;    /// <summary>    /// Integration event raised after setting filters on G/L Entry during detailed G/L account update.    /// Enables additional filtering logic for detailed G/L entry processing.    /// </summary>    /// <param name="GLEntry">G/L Entry record with applied filters</param>    /// <param name="AnalysisView">Analysis view configuration being updated</param>    [IntegrationEvent(false, false)]    local procedure OnUpdateEntriesForGLAccountDetailedOnAfterGLEntrySetFilters(var GLEntry: Record "G/L Entry"; var AnalysisView: Record "Analysis View")    begin    end;    /// <summary>    /// Integration event raised after setting filters on Analysis View Source query during G/L account update.    /// Enables custom query filtering for analysis view source data processing.    /// </summary>    /// <param name="AnalysisViewSourceQry">Analysis View Source query with applied filters</param>    /// <param name="AnalysisView">Analysis view configuration being updated</param>    [IntegrationEvent(false, false)]    local procedure OnUpdateEntriesForGLAccountOnAfterAnalysisViewGLQrySetFilters(var AnalysisViewSourceQry: Query "Analysis View Source";    var        AnalysisView: Record "Analysis View")    begin    end;    /// <summary>    /// Integration event raised after assigning values to temporary Analysis View Budget Entry during update.    /// Enables modification of budget entry data before final processing.    /// </summary>    /// <param name="TempAnalysisViewBudgetEntry">Temporary Analysis View Budget Entry being updated</param>    /// <param name="AnalysisView">Analysis view configuration</param>    /// <param name="GLBudgetEntry">Source G/L Budget Entry</param>    /// <param name="DimValue1">Dimension 1 value code</param>    /// <param name="DimValue2">Dimension 2 value code</param>    /// <param name="DimValue3">Dimension 3 value code</param>    /// <param name="DimValue4">Dimension 4 value code</param>    [IntegrationEvent(false, false)]    local procedure OnUpdateAnalysisViewBudgetEntryOnAfterTempAnalysisViewBudgetEntryAssignment(var TempAnalysisViewBudgetEntry: Record "Analysis View Budget Entry"; var AnalysisView: Record "Analysis View"; var GLBudgetEntry: Record "G/L Budget Entry"; DimValue1: Code[20]; DimValue2: code[20]; DimValue3: Code[20]; DimValue4: Code[20])    begin    end;    /// <summary>    /// Integration event raised after calculating period start date for analysis view updates.    /// Enables custom period calculation logic for different date compression methods.    /// </summary>    /// <param name="AnalysisView">Analysis view configuration</param>    /// <param name="DateCompression">Date compression method being used</param>    /// <param name="AccountingPeriod">Accounting period record for calculations</param>    /// <param name="PostingDate">Posting date being processed</param>    /// <param name="PrevCalculatedPostingDate">Previously calculated posting date</param>    /// <param name="PrevPostingDate">Previous posting date</param>    [IntegrationEvent(false, false)]    local procedure OnAfterCalculatePeriodStart(var AnalysisView: Record "Analysis View"; DateCompression: Integer; var AccountingPeriod: Record "Accounting Period"; var PostingDate: Date; var PrevCalculatedPostingDate: Date; PrevPostingDate: Date)    begin    end;    /// <summary>    /// Integration event raised before updating entries during single analysis view update process.    /// Enables pre-update validation and custom entry processing logic.    /// </summary>    /// <param name="NewAnalysisView">New analysis view configuration</param>    /// <param name="Which">Update type indicating whether to update ledger entries, budget entries, or both</param>    /// <param name="LastReportedEntryNo">Last reported entry number in the update process</param>    /// <param name="TableID">Table ID being processed</param>    /// <param name="Supproted">Whether the operation is supported</param>    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateOneUpdateEntries(var NewAnalysisView: Record "Analysis View"; Which: Option "Ledger Entries","Budget Entries",Both; var LastReportedEntryNo: Integer; var TableID: Integer; var Supproted: Boolean)    begin    end;    /// <summary>    /// Integration event for retrieving entries to update in analysis view processing.    /// Enables custom entry retrieval logic and filtering for analysis view updates.    /// </summary>    /// <param name="AnalysisView">Analysis view configuration</param>    /// <param name="UpdAnalysisViewEntryBuffer">Update Analysis View Entry Buffer for entry staging</param>    [IntegrationEvent(false, false)]    local procedure OnGetEntriesForUpdate(var AnalysisView: Record "Analysis View"; var UpdAnalysisViewEntryBuffer: Record "Upd Analysis View Entry Buffer")    begin    end;    /// <summary>    /// Integration event raised after filtering Analysis View records during update all process.    /// Enables additional processing logic after analysis view filtering is complete.    /// </summary>    /// <param name="AnalysisView">Analysis view record with applied filters</param>    /// <param name="DirectlyFromPosting">Whether update is triggered directly from posting</param>    /// <param name="LastBudgetEntryNo">Last budget entry number processed</param>    [IntegrationEvent(false, false)]    local procedure OnUpdateAllOnAfterFilterAnalysisView2(var AnalysisView: Record "Analysis View"; DirectlyFromPosting: Boolean; LastBudgetEntryNo: Integer)    begin    end;    /// <summary>    /// Integration event raised after assigning values to temporary Analysis View Entry during update.    /// Enables modification of analysis view entry data before final processing.    /// </summary>    /// <param name="TempAnalysisViewEntry">Temporary Analysis View Entry being updated</param>    /// <param name="AnalysisView">Analysis view configuration</param>    /// <param name="GLEntry">Source G/L Entry</param>    /// <param name="UpdAnalysisViewEntryBuffer">Update Analysis View Entry Buffer for staging</param>    [IntegrationEvent(false, false)]    local procedure OnUpdateAnalysisViewEntryOnAfterTempAnalysisViewEntryAssignment(var TempAnalysisViewEntry: Record "Analysis View Entry" temporary; var AnalysisView: Record "Analysis View"; var GLEntry: Record "G/L Entry"; var UpdAnalysisViewEntryBuffer: Record "Upd Analysis View Entry Buffer")    begin    end;}