Codeunit 9500 Sequence No. Mgt.
src/Layers/W1/BaseApp/Foundation/NoSeries/SequenceNoMgt.Codeunit.al350 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.Foundation.NoSeries;codeunit 9500 "Sequence No. Mgt."{ SingleInstance = true; InherentPermissions = X; Permissions = tabledata "Sequence No. Preview State" = rid; var GlobalPreviewMode: Boolean; GlobalPreviewModeID: Integer; LastSeqNoChecked: List of [Integer]; SeqNoBufferFrom: Dictionary of [Integer, Integer]; SeqNoBufferTo: Dictionary of [Integer, Integer]; PendingAllocation: Dictionary of [Integer, Integer]; SeqNameLbl: Label 'TableSeq%1', Comment = '%1 - Table No.', Locked = true; PreviewSeqNameLbl: Label 'PreviewTableSeq%1', Comment = '%1 - Table No.', Locked = true; /// <summary> /// Clears allocations and other internal states /// </summary> procedure ClearState() begin ClearAll(); // may not work for SingleInstance codeunits.... Clear(GlobalPreviewMode); Clear(GlobalPreviewModeID); Clear(LastSeqNoChecked); Clear(SeqNoBufferFrom); Clear(SeqNoBufferFrom); Clear(SeqNoBufferTo); Clear(PendingAllocation); end; /// <summary> /// Allocates sequence numbers for a given table ID. /// if the sequence does not exist, it will be created. /// </summary> /// <param name="TableNo">The ID of the table being checked</param> procedure AllocateSeqNoBuffer(TableNo: Integer; NoOfEntries: Integer) var SignedTableNo: Integer; PreviewMode: Boolean; RemainingNoOfEntries: Integer; begin if NoOfEntries < 2 then // no need reserve 1, as it it still one sql call exit; ValidateSeqNo(TableNo); PreviewMode := IsPreviewMode(); // Only call once to minimize sql calls during preview. SignedTableNo := PreviewMode ? -TableNo : TableNo; if SeqNoBufferFrom.ContainsKey(SignedTableNo) and SeqNoBufferTo.ContainsKey(SignedTableNo) then // lefterovers from previous allocation? RemainingNoOfEntries := SeqNoBufferTo.Get(SignedTableNo) - SeqNoBufferFrom.Get(SignedTableNo); if RemainingNoOfEntries >= NoOfEntries then exit; // we have enough already if PendingAllocation.ContainsKey(SignedTableNo) then PendingAllocation.Set(SignedTableNo, PendingAllocation.Get(SignedTableNo) + NoOfEntries - RemainingNoOfEntries) else PendingAllocation.Add(SignedTableNo, NoOfEntries - RemainingNoOfEntries); end; /// <summary> /// Returns the next buffered NumberSequence value for a given table ID. /// if the sequence does not exist, it will be created. /// </summary> /// <param name="TableNo">The ID of the table being checked</param> procedure GetNextSeqNo(TableNo: Integer): Integer var NewSeqNo: Integer; FromNo: Integer; NoOfEntries: Integer; SignedTableNo: Integer; PreviewMode: Boolean; begin PreviewMode := IsPreviewMode(); // Only call once to minimize sql calls during preview. // First check if we have pre-allocated entry numbers SignedTableNo := PreviewMode ? -TableNo : TableNo; // we use -tableno for index for preview numbers. if PendingAllocation.ContainsKey(SignedTableNo) then if not SeqNoBufferFrom.ContainsKey(SignedTableNo) or not SeqNoBufferTo.ContainsKey(SignedTableNo) then begin NoOfEntries := PendingAllocation.Get(SignedTableNo); PendingAllocation.Remove(SignedTableNo); ValidateSeqNo(TableNo); if not TryGetRange(PreviewMode, TableNo, NoOfEntries, NewSeqNo) then begin ClearLastError(); CreateNewTableSequence(PreviewMode, TableNo); TryGetRange(PreviewMode, TableNo, NoOfEntries, NewSeqNo); end; if SeqNoBufferFrom.ContainsKey(SignedTableNo) then SeqNoBufferFrom.Set(SignedTableNo, NewSeqNo) else SeqNoBufferFrom.Add(SignedTableNo, NewSeqNo); if SeqNoBufferTo.ContainsKey(SignedTableNo) then SeqNoBufferTo.Set(SignedTableNo, NewSeqNo + NoOfEntries - 1) else SeqNoBufferTo.Add(SignedTableNo, NewSeqNo + NoOfEntries - 1); end; if SeqNoBufferFrom.ContainsKey(SignedTableNo) and SeqNoBufferTo.ContainsKey(SignedTableNo) then begin FromNo := SeqNoBufferFrom.Get(SignedTableNo); NewSeqNo := FromNo; FromNo += 1; if FromNo <= SeqNoBufferTo.Get(SignedTableNo) then SeqNoBufferFrom.Set(SignedTableNo, FromNo) else begin if SeqNoBufferFrom.Remove(SignedTableNo) then; if SeqNoBufferTo.Remove(SignedTableNo) then; end; exit(NewSeqNo); end; // No pre-allocated numbers - get entry no. from sequence ValidateSeqNo(TableNo); if TryGetNextNo(PreviewMode, TableNo, NewSeqNo) then exit(NewSeqNo); ClearLastError(); CreateNewTableSequence(PreviewMode, TableNo); TryGetNextNo(PreviewMode, TableNo, NewSeqNo); exit(NewSeqNo); end; /// <summary> /// Returns the current NumberSequence value for a given table ID. /// if the sequence does not exist, it will be created. /// </summary> /// <param name="TableNo">The ID of the table being checked</param> procedure GetCurrentSeqNo(TableNo: Integer): Integer var CurrSeqNo: Integer; PreviewMode: Boolean; begin PreviewMode := IsPreviewMode(); // Only call once to minimize sql calls during preview. if TryGetCurrentNo(PreviewMode, TableNo, CurrSeqNo) then exit(CurrSeqNo); ClearLastError(); CreateNewTableSequence(PreviewMode, TableNo); TryGetCurrentNo(PreviewMode, TableNo, CurrSeqNo); exit(CurrSeqNo); end; /// <summary> /// Ensures that the NumberSequence is not behind the last entry in the table. /// if the sequence does not exist, it will be created. /// The result will be cached for the current transaction. The cache can be cleared by calling ClearSequenceNoCheck. /// </summary> /// <param name="TableNo">The ID of the table being checked</param> procedure ValidateSeqNo(TableNo: Integer) var LastEntryNo: Integer; begin if IsPreviewMode() then exit; if LastSeqNoChecked.Contains(TableNo) then exit; LastEntryNo := GetLastEntryNoFromTable(TableNo, false); if GetCurrentSeqNo(TableNo) < LastEntryNo then RebaseSeqNo(TableNo); LastSeqNoChecked.Add(TableNo); end; /// <summary> /// Clears the cache that is used by procedure ValidateSeqNo(TableNo). /// </summary> procedure ClearSequenceNoCheck() begin Clear(LastSeqNoChecked); end; [TryFunction] local procedure TryGetNextNo(PreviewMode: Boolean; TableNo: Integer; var NewSeqNo: Integer) begin NewSeqNo := NumberSequence.Next(GetTableSequenceName(PreviewMode, TableNo)); end; [TryFunction] local procedure TryGetRange(PreviewMode: Boolean; TableNo: Integer; NoOfEntries: Integer; var NewSeqNo: Integer) begin NewSeqNo := NumberSequence.Range(GetTableSequenceName(PreviewMode, TableNo), NoOfEntries); end; [TryFunction] local procedure TryGetCurrentNo(PreviewMode: Boolean; TableNo: Integer; var CurrSeqNo: Integer) begin CurrSeqNo := NumberSequence.Current(GetTableSequenceName(PreviewMode, TableNo)); end; /// <summary> /// Restarts or recreates the NumberSequence for the specified Table ID. /// </summary> /// <param name="TableNo">The ID of the table being checked</param> procedure RebaseSeqNo(TableNo: Integer) begin CreateNewTableSequence(IsPreviewMode(), TableNo); end; local procedure CreateNewTableSequence(PreviewMode: Boolean; TableNo: Integer) var StartSeqNo: BigInteger; IsPreviewable: Boolean; begin OnPreviewableLedgerEntry(TableNo, IsPreviewable); if PreviewMode and IsPreviewable then StartSeqNo := -2000000000 else StartSeqNo := GetLastEntryNoFromTable(TableNo, true) + 1; CreateSequence(GetTableSequenceName(PreviewMode and IsPreviewable, TableNo), StartSeqNo); if PreviewMode or not IsPreviewable then exit; // Creating/deleting a number sequence is transactional, so we benefit from creating the preview sequence in a non-preview transaction CreateSequence(GetTableSequenceName(true, TableNo), -2000000000); end; local procedure CreateSequence(SequenceName: Text; StartSeqNo: BigInteger) begin if NumberSequence.Exists(SequenceName) then NumberSequence.Restart(SequenceName, StartSeqNo - 1) // to avoid the issue with current and next being the same for a new sequence. else NumberSequence.Insert(SequenceName, StartSeqNo - 1, 1, true); // to avoid the issue with current and next being the same for a new sequence. if NumberSequence.Next(SequenceName) = 1 then; // do. end; local procedure GetLastEntryNoFromTable(TableNo: Integer; WithLock: Boolean): BigInteger var [SecurityFiltering(SecurityFilter::Ignored)] RecRef: RecordRef; FldRef: FieldRef; KeyRef: KeyRef; LastEntryNo: BigInteger; begin OnBeforeGetLastEntryNoFromTable(TableNo); RecRef.Open(TableNo); if WithLock then RecRef.ReadIsolation(IsolationLevel::UpdLock) else RecRef.ReadIsolation(IsolationLevel::ReadUncommitted); KeyRef := RecRef.KeyIndex(1); RecRef.SetLoadFields(KeyRef.FieldIndex(KeyRef.FieldCount).Number); if RecRef.FindLast() then begin FldRef := KeyRef.FieldIndex(KeyRef.FieldCount); LastEntryNo := FldRef.Value end else LastEntryNo := 0; OnAfterGetLastEntryNoFromTable(TableNo); exit(LastEntryNo); end; /// <summary> /// Returns the name of the NumberSequence for the specified Table ID. /// </summary> /// <param name="TableNo">The ID of the table being checked</param> procedure GetTableSequenceName(TableNo: Integer): Text begin exit(GetTableSequenceName(IsPreviewMode(), TableNo)); end; /// <summary> /// Returns the name of the NumberSequence for the specified Table ID. We have one sequence for preview and one for non-preview. /// </summary> /// <param name="PreviewMode">Is true for posting preview</param> /// <param name="TableNo">The ID of the table being checked</param> procedure GetTableSequenceName(PreviewMode: Boolean; TableNo: Integer): Text var IsPreviewable: Boolean; begin if PreviewMode then OnPreviewableLedgerEntry(TableNo, IsPreviewable); if IsPreviewable then exit(StrSubstNo(PreviewSeqNameLbl, TableNo)); exit(StrSubstNo(SeqNameLbl, TableNo)); end; // An error during preview may mean that the PreviewMode variable doesn't get reset after preview, so we need to rely on transactional consistency local procedure IsPreviewMode(): Boolean var SequenceNoPreviewState: Record "Sequence No. Preview State"; begin if not GlobalPreviewMode then exit(false); if GlobalPreviewModeID <> 0 then if SequenceNoPreviewState.Get(GlobalPreviewModeID) then // double-check exit(true); GlobalPreviewMode := false; GlobalPreviewModeID := 0; end; internal procedure StartPreviewMode() var SequenceNoPreviewState: Record "Sequence No. Preview State"; begin if GlobalPreviewMode then // missing cleanup from previous preview? StopPreviewMode(); SequenceNoPreviewState.ID := 0; SequenceNoPreviewState.Insert(); SequenceNoPreviewState.Consistent(false); // make sure we cannot commit the transaction GlobalPreviewMode := true; GlobalPreviewModeID := SequenceNoPreviewState.ID; end; internal procedure StopPreviewMode() var SequenceNoPreviewState: Record "Sequence No. Preview State"; begin GlobalPreviewMode := false; if GlobalPreviewModeID <> 0 then if SequenceNoPreviewState.Get(GlobalPreviewModeID) then SequenceNoPreviewState.Delete(); GlobalPreviewModeID := 0; SequenceNoPreviewState.Consistent(true); // make sure we can commit the transaction end; internal procedure SetPreviewMode(NewPreviewMode: Boolean) begin if NewPreviewMode then StartPreviewMode() else StopPreviewMode(); end; [IntegrationEvent(false, false)] local procedure OnPreviewableLedgerEntry(TableNo: Integer; var IsPreviewable: Boolean) begin end; /// <summary> /// Integration event raised at the beginning of GetLastEntryNoFromTable, before the table is opened. /// Allows extensions to remove filters (for example global dimension filters) that could affect the last entry number lookup. /// </summary> /// <param name="TableNo">The ID of the table being read.</param> [IntegrationEvent(false, false)] local procedure OnBeforeGetLastEntryNoFromTable(TableNo: Integer) begin end; /// <summary> /// Integration event raised at the end of GetLastEntryNoFromTable, after the last entry number has been read. /// Allows extensions to reapply filters that were removed in OnBeforeGetLastEntryNoFromTable. /// </summary> /// <param name="TableNo">The ID of the table being read.</param> [IntegrationEvent(false, false)] local procedure OnAfterGetLastEntryNoFromTable(TableNo: Integer) begin end;}