@jwikman/bc-code-intelligence-mcp 1.5.7-dev.1

package/embedded-knowledge/domains/dean-debug/samples/no-series-implementation.md

@@ -0,0 +1,810 @@
+# No Series Implementation Patterns - AL Code Examples
+
+This sample demonstrates implementing robust number generation and sequence management in Business Central.
+
+## Basic No Series Implementation
+
+```al
+// Custom number generation codeunit
+codeunit 50500 "Custom No. Series Management"
+{
+    procedure GetNextNo(NoSeriesCode: Code[20]; SeriesDate: Date): Code[20]
+    var
+        NoSeries: Record "No. Series";
+        NoSeriesLine: Record "No. Series Line";
+        NextNo: Code[20];
+    begin
+        if not NoSeries.Get(NoSeriesCode) then
+            Error('No. Series %1 does not exist', NoSeriesCode);
+
+        NoSeriesLine := FindApplicableNoSeriesLine(NoSeriesCode, SeriesDate);
+        NextNo := GenerateNextNumber(NoSeriesLine);
+
+        UpdateNoSeriesLine(NoSeriesLine, NextNo);
+        LogNumberGeneration(NoSeriesCode, NextNo);
+
+        exit(NextNo);
+    end;
+
+    procedure GetNextNoWithGapManagement(NoSeriesCode: Code[20]; SeriesDate: Date; FillGaps: Boolean): Code[20]
+    var
+        NextNo: Code[20];
+        GapNo: Code[20];
+    begin
+        if FillGaps then begin
+            GapNo := FindFirstGap(NoSeriesCode);
+            if GapNo <> '' then begin
+                MarkGapAsFilled(NoSeriesCode, GapNo);
+                exit(GapNo);
+            end;
+        end;
+
+        exit(GetNextNo(NoSeriesCode, SeriesDate));
+    end;
+
+    procedure CreateCustomNoSeries(NoSeriesCode: Code[20]; Description: Text[100]; StartingNo: Code[20]; EndingNo: Code[20]): Boolean
+    var
+        NoSeries: Record "No. Series";
+        NoSeriesLine: Record "No. Series Line";
+    begin
+        // Create No. Series header
+        if NoSeries.Get(NoSeriesCode) then
+            exit(false); // Already exists
+
+        NoSeries.Init();
+        NoSeries.Code := NoSeriesCode;
+        NoSeries.Description := Description;
+        NoSeries."Default Nos." := true;
+        NoSeries."Manual Nos." := false;
+        NoSeries.Insert(true);
+
+        // Create No. Series line
+        NoSeriesLine.Init();
+        NoSeriesLine."Series Code" := NoSeriesCode;
+        NoSeriesLine."Line No." := 10000;
+        NoSeriesLine."Starting Date" := Today;
+        NoSeriesLine."Starting No." := StartingNo;
+        NoSeriesLine."Ending No." := EndingNo;
+        NoSeriesLine."Last No. Used" := '';
+        NoSeriesLine."Increment-by No." := 1;
+        NoSeriesLine.Insert(true);
+
+        exit(true);
+    end;
+
+    local procedure FindApplicableNoSeriesLine(NoSeriesCode: Code[20]; SeriesDate: Date): Record "No. Series Line"
+    var
+        NoSeriesLine: Record "No. Series Line";
+    begin
+        NoSeriesLine.SetRange("Series Code", NoSeriesCode);
+        NoSeriesLine.SetFilter("Starting Date", '<=%1', SeriesDate);
+        NoSeriesLine.SetFilter("Ending Date", '%1|>=%2', 0D, SeriesDate);
+
+        if not NoSeriesLine.FindLast() then
+            Error('No applicable No. Series Line found for %1 on %2', NoSeriesCode, SeriesDate);
+
+        exit(NoSeriesLine);
+    end;
+
+    local procedure GenerateNextNumber(var NoSeriesLine: Record "No. Series Line"): Code[20]
+    var
+        NextNo: Code[20];
+        NumberPart: BigInteger;
+        PrefixPart: Text;
+        SuffixPart: Text;
+        NumberLength: Integer;
+    begin
+        if NoSeriesLine."Last No. Used" = '' then
+            NextNo := NoSeriesLine."Starting No."
+        else begin
+            // Parse current number
+            ParseNumberComponents(NoSeriesLine."Last No. Used", PrefixPart, NumberPart, SuffixPart, NumberLength);
+
+            // Increment number
+            NumberPart += NoSeriesLine."Increment-by No.";
+
+            // Reconstruct number
+            NextNo := ReconstructNumber(PrefixPart, NumberPart, SuffixPart, NumberLength);
+        end;
+
+        // Validate against ending number
+        if (NoSeriesLine."Ending No." <> '') and (NextNo > NoSeriesLine."Ending No.") then
+            Error('No. Series %1 has reached its ending number %2', NoSeriesLine."Series Code", NoSeriesLine."Ending No.");
+
+        exit(NextNo);
+    end;
+
+    local procedure UpdateNoSeriesLine(var NoSeriesLine: Record "No. Series Line"; NextNo: Code[20])
+    begin
+        NoSeriesLine."Last No. Used" := NextNo;
+        NoSeriesLine."Last Date Used" := Today;
+        NoSeriesLine.Modify(true);
+    end;
+
+    local procedure ParseNumberComponents(NumberStr: Code[20]; var Prefix: Text; var Number: BigInteger; var Suffix: Text; var NumberLength: Integer)
+    var
+        i: Integer;
+        CurrentChar: Char;
+        NumberStartPos: Integer;
+        NumberEndPos: Integer;
+        NumberPart: Text;
+    begin
+        Clear(Prefix);
+        Clear(Suffix);
+        Number := 0;
+        NumberLength := 0;
+        NumberStartPos := 0;
+        NumberEndPos := 0;
+
+        // Find the start of the numeric part
+        for i := 1 to StrLen(NumberStr) do begin
+            CurrentChar := NumberStr[i];
+            if CurrentChar in ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] then begin
+                if NumberStartPos = 0 then
+                    NumberStartPos := i;
+                NumberEndPos := i;
+            end else begin
+                if NumberStartPos > 0 then
+                    break;
+            end;
+        end;
+
+        if NumberStartPos > 0 then begin
+            // Extract components
+            if NumberStartPos > 1 then
+                Prefix := CopyStr(NumberStr, 1, NumberStartPos - 1);
+
+            NumberPart := CopyStr(NumberStr, NumberStartPos, NumberEndPos - NumberStartPos + 1);
+            NumberLength := StrLen(NumberPart);
+            Evaluate(Number, NumberPart);
+
+            if NumberEndPos < StrLen(NumberStr) then
+                Suffix := CopyStr(NumberStr, NumberEndPos + 1);
+        end;
+    end;
+
+    local procedure ReconstructNumber(Prefix: Text; Number: BigInteger; Suffix: Text; NumberLength: Integer): Code[20]
+    var
+        NumberPart: Text;
+        Result: Text;
+    begin
+        NumberPart := Format(Number);
+
+        // Pad with leading zeros if necessary
+        while StrLen(NumberPart) < NumberLength do
+            NumberPart := '0' + NumberPart;
+
+        Result := Prefix + NumberPart + Suffix;
+        exit(CopyStr(Result, 1, 20));
+    end;
+
+    local procedure FindFirstGap(NoSeriesCode: Code[20]): Code[20]
+    var
+        NoSeriesGap: Record "No. Series Gap";
+    begin
+        NoSeriesGap.SetRange("Series Code", NoSeriesCode);
+        NoSeriesGap.SetRange(Filled, false);
+        if NoSeriesGap.FindFirst() then
+            exit(NoSeriesGap."Gap No.");
+
+        exit('');
+    end;
+
+    local procedure MarkGapAsFilled(NoSeriesCode: Code[20]; GapNo: Code[20])
+    var
+        NoSeriesGap: Record "No. Series Gap";
+    begin
+        if NoSeriesGap.Get(NoSeriesCode, GapNo) then begin
+            NoSeriesGap.Filled := true;
+            NoSeriesGap."Fill Date" := Today;
+            NoSeriesGap."Fill Time" := Time;
+            NoSeriesGap.Modify(true);
+        end;
+    end;
+
+    local procedure LogNumberGeneration(NoSeriesCode: Code[20]; GeneratedNo: Code[20])
+    var
+        NoSeriesLog: Record "No. Series Log";
+    begin
+        NoSeriesLog.Init();
+        NoSeriesLog."Entry No." := GetNextLogEntryNo();
+        NoSeriesLog."Series Code" := NoSeriesCode;
+        NoSeriesLog."Generated No." := GeneratedNo;
+        NoSeriesLog."Generation Date" := Today;
+        NoSeriesLog."Generation Time" := Time;
+        NoSeriesLog."User ID" := UserId;
+        NoSeriesLog.Insert(true);
+    end;
+
+    local procedure GetNextLogEntryNo(): Integer
+    var
+        NoSeriesLog: Record "No. Series Log";
+    begin
+        if NoSeriesLog.FindLast() then
+            exit(NoSeriesLog."Entry No." + 1)
+        else
+            exit(1);
+    end;
+}
+```
+
+## Concurrency-Safe Number Generation
+
+```al
+// High-performance number generation with concurrency control
+codeunit 50501 "Concurrent No. Series Management"
+{
+    procedure GetNextNoSafe(NoSeriesCode: Code[20]; SeriesDate: Date): Code[20]
+    var
+        NoSeriesLine: Record "No. Series Line";
+        NextNo: Code[20];
+        RetryCount: Integer;
+        MaxRetries: Integer;
+    begin
+        MaxRetries := 10;
+        RetryCount := 0;
+
+        repeat
+            RetryCount += 1;
+
+            if TryGetNextNoWithLock(NoSeriesCode, SeriesDate, NextNo) then
+                exit(NextNo);
+
+            if RetryCount >= MaxRetries then
+                Error('Unable to generate next number after %1 attempts. Series may be in use by another user.', MaxRetries);
+
+            // Wait before retry (exponential backoff)
+            Sleep(RetryCount * 100);
+
+        until false;
+    end;
+
+    [TryFunction]
+    local procedure TryGetNextNoWithLock(NoSeriesCode: Code[20]; SeriesDate: Date; var NextNo: Code[20])
+    var
+        NoSeriesLine: Record "No. Series Line";
+        NoSeriesLock: Record "No. Series Lock";
+        LockAcquired: Boolean;
+    begin
+        // Attempt to acquire lock
+        LockAcquired := TryAcquireSeriesLock(NoSeriesCode);
+        if not LockAcquired then
+            Error('Lock not acquired');
+
+        try
+            // Find applicable line
+            NoSeriesLine := FindApplicableNoSeriesLine(NoSeriesCode, SeriesDate);
+
+            // Generate next number
+            NextNo := GenerateNextNumberSafe(NoSeriesLine);
+
+            // Update line
+            UpdateNoSeriesLineSafe(NoSeriesLine, NextNo);
+
+            // Commit changes
+            Commit();
+
+        finally
+            // Always release lock
+            ReleaseSeriesLock(NoSeriesCode);
+        end;
+    end;
+
+    [TryFunction]
+    local procedure TryAcquireSeriesLock(NoSeriesCode: Code[20]): Boolean
+    var
+        NoSeriesLock: Record "No. Series Lock";
+        LockTimeout: DateTime;
+    begin
+        LockTimeout := CurrentDateTime + 5000; // 5 second timeout
+
+        NoSeriesLock.SetRange("Series Code", NoSeriesCode);
+
+        repeat
+            if not NoSeriesLock.FindFirst() then begin
+                // Create lock record
+                NoSeriesLock.Init();
+                NoSeriesLock."Series Code" := NoSeriesCode;
+                NoSeriesLock."Locked By" := UserId;
+                NoSeriesLock."Lock Time" := CurrentDateTime;
+                NoSeriesLock.Insert(true);
+                exit(true);
+            end;
+
+            // Check if lock is stale (older than 1 minute)
+            if NoSeriesLock."Lock Time" < (CurrentDateTime - 60000) then begin
+                NoSeriesLock.Delete(true);
+                continue;
+            end;
+
+            Sleep(50); // Wait 50ms before retry
+
+        until CurrentDateTime > LockTimeout;
+
+        exit(false);
+    end;
+
+    local procedure ReleaseSeriesLock(NoSeriesCode: Code[20])
+    var
+        NoSeriesLock: Record "No. Series Lock";
+    begin
+        NoSeriesLock.SetRange("Series Code", NoSeriesCode);
+        NoSeriesLock.SetRange("Locked By", UserId);
+        if NoSeriesLock.FindFirst() then
+            NoSeriesLock.Delete(true);
+    end;
+
+    local procedure FindApplicableNoSeriesLine(NoSeriesCode: Code[20]; SeriesDate: Date): Record "No. Series Line"
+    var
+        NoSeriesLine: Record "No. Series Line";
+    begin
+        NoSeriesLine.SetRange("Series Code", NoSeriesCode);
+        NoSeriesLine.SetFilter("Starting Date", '<=%1', SeriesDate);
+        NoSeriesLine.SetFilter("Ending Date", '%1|>=%2', 0D, SeriesDate);
+
+        if not NoSeriesLine.FindLast() then
+            Error('No applicable No. Series Line found for %1 on %2', NoSeriesCode, SeriesDate);
+
+        exit(NoSeriesLine);
+    end;
+
+    local procedure GenerateNextNumberSafe(var NoSeriesLine: Record "No. Series Line"): Code[20]
+    var
+        NextNo: Code[20];
+        LastUsedNo: Code[20];
+    begin
+        // Re-read to get latest values
+        NoSeriesLine.Find();
+
+        if NoSeriesLine."Last No. Used" = '' then
+            NextNo := NoSeriesLine."Starting No."
+        else begin
+            NextNo := IncrementNumber(NoSeriesLine."Last No. Used", NoSeriesLine."Increment-by No.");
+        end;
+
+        // Validate against ending number
+        if (NoSeriesLine."Ending No." <> '') and (NextNo > NoSeriesLine."Ending No.") then
+            Error('No. Series %1 has reached its ending number %2', NoSeriesLine."Series Code", NoSeriesLine."Ending No.");
+
+        exit(NextNo);
+    end;
+
+    local procedure UpdateNoSeriesLineSafe(var NoSeriesLine: Record "No. Series Line"; NextNo: Code[20])
+    begin
+        NoSeriesLine."Last No. Used" := NextNo;
+        NoSeriesLine."Last Date Used" := Today;
+        NoSeriesLine.Modify(true);
+    end;
+
+    local procedure IncrementNumber(CurrentNo: Code[20]; IncrementBy: Integer): Code[20]
+    var
+        NumberPart: BigInteger;
+        PrefixPart: Text;
+        SuffixPart: Text;
+        NumberLength: Integer;
+    begin
+        ParseNumberComponents(CurrentNo, PrefixPart, NumberPart, SuffixPart, NumberLength);
+        NumberPart += IncrementBy;
+        exit(ReconstructNumber(PrefixPart, NumberPart, SuffixPart, NumberLength));
+    end;
+
+    local procedure ParseNumberComponents(NumberStr: Code[20]; var Prefix: Text; var Number: BigInteger; var Suffix: Text; var NumberLength: Integer)
+    begin
+        // Implementation from previous example
+    end;
+
+    local procedure ReconstructNumber(Prefix: Text; Number: BigInteger; Suffix: Text; NumberLength: Integer): Code[20]
+    begin
+        // Implementation from previous example
+    end;
+}
+```
+
+## Batch Number Allocation
+
+```al
+// Optimized batch allocation for high-volume scenarios
+codeunit 50502 "Batch No. Series Allocation"
+{
+    var
+        AllocatedNumbers: Dictionary of [Code[20], List of [Code[20]]];
+
+    procedure AllocateNumberBatch(NoSeriesCode: Code[20]; BatchSize: Integer): List of [Code[20]]
+    var
+        NoSeriesLine: Record "No. Series Line";
+        AllocatedBatch: List of [Code[20]];
+        NextNo: Code[20];
+        i: Integer;
+    begin
+        if BatchSize <= 0 then
+            Error('Batch size must be greater than zero');
+
+        if BatchSize > 1000 then
+            Error('Batch size cannot exceed 1000');
+
+        // Lock the series for batch allocation
+        LockNoSeriesForBatch(NoSeriesCode);
+
+        try
+            NoSeriesLine := FindApplicableNoSeriesLine(NoSeriesCode, Today);
+
+            // Allocate batch
+            for i := 1 to BatchSize do begin
+                NextNo := GenerateNextNumberInBatch(NoSeriesLine, i);
+                AllocatedBatch.Add(NextNo);
+            end;
+
+            // Update the line with the last allocated number
+            UpdateNoSeriesLineForBatch(NoSeriesLine, AllocatedBatch.Get(BatchSize));
+
+            // Cache allocated numbers
+            AllocatedNumbers.Set(NoSeriesCode, AllocatedBatch);
+
+            Commit();
+
+        finally
+            UnlockNoSeriesForBatch(NoSeriesCode);
+        end;
+
+        exit(AllocatedBatch);
+    end;
+
+    procedure GetNextFromBatch(NoSeriesCode: Code[20]): Code[20]
+    var
+        BatchList: List of [Code[20]];
+        NextNo: Code[20];
+    begin
+        if not AllocatedNumbers.Get(NoSeriesCode, BatchList) then
+            Error('No allocated batch found for series %1', NoSeriesCode);
+
+        if BatchList.Count = 0 then begin
+            // Batch exhausted, allocate new batch
+            BatchList := AllocateNumberBatch(NoSeriesCode, 100); // Default batch size
+        end;
+
+        NextNo := BatchList.Get(1);
+        BatchList.RemoveAt(1);
+        AllocatedNumbers.Set(NoSeriesCode, BatchList);
+
+        LogBatchUsage(NoSeriesCode, NextNo);
+
+        exit(NextNo);
+    end;
+
+    procedure GetBatchStatus(NoSeriesCode: Code[20]): Dictionary of [Text, Variant]
+    var
+        Status: Dictionary of [Text, Variant];
+        BatchList: List of [Code[20]];
+    begin
+        Status.Set('SeriesCode', NoSeriesCode);
+
+        if AllocatedNumbers.Get(NoSeriesCode, BatchList) then begin
+            Status.Set('HasBatch', true);
+            Status.Set('RemainingNumbers', BatchList.Count);
+            if BatchList.Count > 0 then begin
+                Status.Set('NextAvailable', BatchList.Get(1));
+                Status.Set('LastInBatch', BatchList.Get(BatchList.Count));
+            end;
+        end else begin
+            Status.Set('HasBatch', false);
+            Status.Set('RemainingNumbers', 0);
+        end;
+
+        exit(Status);
+    end;
+
+    local procedure FindApplicableNoSeriesLine(NoSeriesCode: Code[20]; SeriesDate: Date): Record "No. Series Line"
+    var
+        NoSeriesLine: Record "No. Series Line";
+    begin
+        NoSeriesLine.SetRange("Series Code", NoSeriesCode);
+        NoSeriesLine.SetFilter("Starting Date", '<=%1', SeriesDate);
+        NoSeriesLine.SetFilter("Ending Date", '%1|>=%2', 0D, SeriesDate);
+
+        if not NoSeriesLine.FindLast() then
+            Error('No applicable No. Series Line found for %1 on %2', NoSeriesCode, SeriesDate);
+
+        exit(NoSeriesLine);
+    end;
+
+    local procedure GenerateNextNumberInBatch(var NoSeriesLine: Record "No. Series Line"; BatchIndex: Integer): Code[20]
+    var
+        BaseNumber: Code[20];
+        NumberPart: BigInteger;
+        PrefixPart: Text;
+        SuffixPart: Text;
+        NumberLength: Integer;
+    begin
+        if BatchIndex = 1 then begin
+            if NoSeriesLine."Last No. Used" = '' then
+                BaseNumber := NoSeriesLine."Starting No."
+            else
+                BaseNumber := IncrementNumber(NoSeriesLine."Last No. Used", NoSeriesLine."Increment-by No.");
+        end else begin
+            BaseNumber := IncrementNumber(BaseNumber, NoSeriesLine."Increment-by No.");
+        end;
+
+        // Validate against ending number
+        if (NoSeriesLine."Ending No." <> '') and (BaseNumber > NoSeriesLine."Ending No.") then
+            Error('No. Series %1 would exceed its ending number %2 in batch allocation', NoSeriesLine."Series Code", NoSeriesLine."Ending No.");
+
+        exit(BaseNumber);
+    end;
+
+    local procedure UpdateNoSeriesLineForBatch(var NoSeriesLine: Record "No. Series Line"; LastAllocatedNo: Code[20])
+    begin
+        NoSeriesLine."Last No. Used" := LastAllocatedNo;
+        NoSeriesLine."Last Date Used" := Today;
+        NoSeriesLine.Modify(true);
+    end;
+
+    local procedure LockNoSeriesForBatch(NoSeriesCode: Code[20])
+    var
+        NoSeriesBatchLock: Record "No. Series Batch Lock";
+    begin
+        NoSeriesBatchLock.Init();
+        NoSeriesBatchLock."Series Code" := NoSeriesCode;
+        NoSeriesBatchLock."Locked By" := UserId;
+        NoSeriesBatchLock."Lock Time" := CurrentDateTime;
+        NoSeriesBatchLock.Insert(true);
+    end;
+
+    local procedure UnlockNoSeriesForBatch(NoSeriesCode: Code[20])
+    var
+        NoSeriesBatchLock: Record "No. Series Batch Lock";
+    begin
+        NoSeriesBatchLock.SetRange("Series Code", NoSeriesCode);
+        NoSeriesBatchLock.SetRange("Locked By", UserId);
+        if NoSeriesBatchLock.FindFirst() then
+            NoSeriesBatchLock.Delete(true);
+    end;
+
+    local procedure IncrementNumber(CurrentNo: Code[20]; IncrementBy: Integer): Code[20]
+    begin
+        // Implementation from previous examples
+    end;
+
+    local procedure LogBatchUsage(NoSeriesCode: Code[20]; UsedNo: Code[20])
+    var
+        NoSeriesBatchLog: Record "No. Series Batch Log";
+    begin
+        NoSeriesBatchLog.Init();
+        NoSeriesBatchLog."Entry No." := GetNextBatchLogEntryNo();
+        NoSeriesBatchLog."Series Code" := NoSeriesCode;
+        NoSeriesBatchLog."Used No." := UsedNo;
+        NoSeriesBatchLog."Usage Date" := Today;
+        NoSeriesBatchLog."Usage Time" := Time;
+        NoSeriesBatchLog."User ID" := UserId;
+        NoSeriesBatchLog.Insert(true);
+    end;
+
+    local procedure GetNextBatchLogEntryNo(): Integer
+    var
+        NoSeriesBatchLog: Record "No. Series Batch Log";
+    begin
+        if NoSeriesBatchLog.FindLast() then
+            exit(NoSeriesBatchLog."Entry No." + 1)
+        else
+            exit(1);
+    end;
+}
+```
+
+## Multi-Dimensional Number Generation
+
+```al
+// Support for complex numbering schemes with multiple dimensions
+codeunit 50503 "Multi-Dimensional No. Series"
+{
+    procedure GetNextCompoundNo(BaseSeriesCode: Code[20]; Dimensions: Dictionary of [Text, Text]): Code[20]
+    var
+        CompoundCode: Code[20];
+        GeneratedNo: Code[20];
+    begin
+        CompoundCode := BuildCompoundSeriesCode(BaseSeriesCode, Dimensions);
+        GeneratedNo := GetOrCreateCompoundSeries(CompoundCode, Dimensions);
+
+        LogCompoundNumberGeneration(BaseSeriesCode, CompoundCode, GeneratedNo, Dimensions);
+
+        exit(GeneratedNo);
+    end;
+
+    procedure GetLocationBasedNo(BaseSeriesCode: Code[20]; LocationCode: Code[10]): Code[20]
+    var
+        Dimensions: Dictionary of [Text, Text];
+    begin
+        Dimensions.Set('LOCATION', LocationCode);
+        exit(GetNextCompoundNo(BaseSeriesCode, Dimensions));
+    end;
+
+    procedure GetYearBasedNo(BaseSeriesCode: Code[20]; FiscalYear: Integer): Code[20]
+    var
+        Dimensions: Dictionary of [Text, Text];
+    begin
+        Dimensions.Set('YEAR', Format(FiscalYear));
+        exit(GetNextCompoundNo(BaseSeriesCode, Dimensions));
+    end;
+
+    procedure GetDepartmentBasedNo(BaseSeriesCode: Code[20]; DepartmentCode: Code[10]; LocationCode: Code[10]): Code[20]
+    var
+        Dimensions: Dictionary of [Text, Text];
+    begin
+        Dimensions.Set('DEPARTMENT', DepartmentCode);
+        Dimensions.Set('LOCATION', LocationCode);
+        exit(GetNextCompoundNo(BaseSeriesCode, Dimensions));
+    end;
+
+    local procedure BuildCompoundSeriesCode(BaseSeriesCode: Code[20]; Dimensions: Dictionary of [Text, Text]): Code[20]
+    var
+        CompoundCode: Text;
+        DimensionKey: Text;
+        DimensionValue: Text;
+        SortedKeys: List of [Text];
+    begin
+        CompoundCode := BaseSeriesCode;
+
+        // Sort dimension keys for consistent ordering
+        foreach DimensionKey in Dimensions.Keys do
+            SortedKeys.Add(DimensionKey);
+
+        SortDimensionKeys(SortedKeys);
+
+        // Build compound code
+        foreach DimensionKey in SortedKeys do begin
+            Dimensions.Get(DimensionKey, DimensionValue);
+            CompoundCode += '-' + DimensionKey + '-' + DimensionValue;
+        end;
+
+        // Ensure code fits in 20 characters
+        if StrLen(CompoundCode) > 20 then
+            CompoundCode := CreateHashedCompoundCode(BaseSeriesCode, Dimensions);
+
+        exit(CopyStr(CompoundCode, 1, 20));
+    end;
+
+    local procedure GetOrCreateCompoundSeries(CompoundCode: Code[20]; Dimensions: Dictionary of [Text, Text]): Code[20]
+    var
+        NoSeries: Record "No. Series";
+        CustomNoSeriesManagement: Codeunit "Custom No. Series Management";
+        StartingNo: Code[20];
+        EndingNo: Code[20];
+    begin
+        if not NoSeries.Get(CompoundCode) then begin
+            // Create new compound series
+            StartingNo := BuildStartingNumber(Dimensions);
+            EndingNo := BuildEndingNumber(Dimensions);
+
+            if not CustomNoSeriesManagement.CreateCustomNoSeries(
+                CompoundCode,
+                'Auto-generated compound series',
+                StartingNo,
+                EndingNo) then
+                Error('Failed to create compound No. Series %1', CompoundCode);
+        end;
+
+        exit(CustomNoSeriesManagement.GetNextNo(CompoundCode, Today));
+    end;
+
+    local procedure BuildStartingNumber(Dimensions: Dictionary of [Text, Text]): Code[20]
+    var
+        StartingNo: Text;
+        DimensionKey: Text;
+        DimensionValue: Text;
+    begin
+        StartingNo := '';
+
+        // Build starting number based on dimensions
+        if Dimensions.Get('LOCATION', DimensionValue) then
+            StartingNo += DimensionValue;
+
+        if Dimensions.Get('DEPARTMENT', DimensionValue) then
+            StartingNo += DimensionValue;
+
+        if Dimensions.Get('YEAR', DimensionValue) then
+            StartingNo += CopyStr(DimensionValue, 3, 2); // Last 2 digits of year
+
+        StartingNo += '00001';
+
+        exit(CopyStr(StartingNo, 1, 20));
+    end;
+
+    local procedure BuildEndingNumber(Dimensions: Dictionary of [Text, Text]): Code[20]
+    var
+        EndingNo: Text;
+        DimensionKey: Text;
+        DimensionValue: Text;
+    begin
+        EndingNo := '';
+
+        // Build ending number based on dimensions
+        if Dimensions.Get('LOCATION', DimensionValue) then
+            EndingNo += DimensionValue;
+
+        if Dimensions.Get('DEPARTMENT', DimensionValue) then
+            EndingNo += DimensionValue;
+
+        if Dimensions.Get('YEAR', DimensionValue) then
+            EndingNo += CopyStr(DimensionValue, 3, 2); // Last 2 digits of year
+
+        EndingNo += '99999';
+
+        exit(CopyStr(EndingNo, 1, 20));
+    end;
+
+    local procedure CreateHashedCompoundCode(BaseSeriesCode: Code[20]; Dimensions: Dictionary of [Text, Text]): Code[20]
+    var
+        HashInput: Text;
+        DimensionKey: Text;
+        DimensionValue: Text;
+        HashValue: Text;
+    begin
+        HashInput := BaseSeriesCode;
+
+        foreach DimensionKey in Dimensions.Keys do begin
+            Dimensions.Get(DimensionKey, DimensionValue);
+            HashInput += DimensionKey + DimensionValue;
+        end;
+
+        // Create simple hash (in production, use proper hashing)
+        HashValue := Format(HashInput.GetHashCode(), 0, '<Integer,8><Filler Character,0>');
+
+        exit(CopyStr(BaseSeriesCode + '-' + HashValue, 1, 20));
+    end;
+
+    local procedure SortDimensionKeys(var Keys: List of [Text])
+    var
+        i, j: Integer;
+        temp: Text;
+    begin
+        // Simple bubble sort for demonstration
+        for i := 1 to Keys.Count - 1 do begin
+            for j := 1 to Keys.Count - i do begin
+                if Keys.Get(j) > Keys.Get(j + 1) then begin
+                    temp := Keys.Get(j);
+                    Keys.Set(j, Keys.Get(j + 1));
+                    Keys.Set(j + 1, temp);
+                end;
+            end;
+        end;
+    end;
+
+    local procedure LogCompoundNumberGeneration(BaseSeriesCode: Code[20]; CompoundCode: Code[20]; GeneratedNo: Code[20]; Dimensions: Dictionary of [Text, Text])
+    var
+        CompoundNoLog: Record "Compound No. Log";
+        DimensionText: Text;
+        DimensionKey: Text;
+        DimensionValue: Text;
+    begin
+        // Build dimension text
+        foreach DimensionKey in Dimensions.Keys do begin
+            Dimensions.Get(DimensionKey, DimensionValue);
+            if DimensionText <> '' then
+                DimensionText += '; ';
+            DimensionText += DimensionKey + '=' + DimensionValue;
+        end;
+
+        CompoundNoLog.Init();
+        CompoundNoLog."Entry No." := GetNextCompoundLogEntryNo();
+        CompoundNoLog."Base Series Code" := BaseSeriesCode;
+        CompoundNoLog."Compound Series Code" := CompoundCode;
+        CompoundNoLog."Generated No." := GeneratedNo;
+        CompoundNoLog."Dimensions" := CopyStr(DimensionText, 1, 250);
+        CompoundNoLog."Generation Date" := Today;
+        CompoundNoLog."Generation Time" := Time;
+        CompoundNoLog."User ID" := UserId;
+        CompoundNoLog.Insert(true);
+    end;
+
+    local procedure GetNextCompoundLogEntryNo(): Integer
+    var
+        CompoundNoLog: Record "Compound No. Log";
+    begin
+        if CompoundNoLog.FindLast() then
+            exit(CompoundNoLog."Entry No." + 1)
+        else
+            exit(1);
+    end;
+}
+```
+
+This comprehensive implementation provides robust number generation capabilities including basic number series management, concurrency control, batch allocation, and multi-dimensional numbering for complex Business Central scenarios.