bc-code-intelligence-mcp 1.1.1

package/embedded-knowledge/domains/dean-debug/samples/case-performance-optimization.md

@@ -0,0 +1,60 @@
+# Case Statement Performance Optimization - AL Code Samples
+
+## Frequency-Based Ordering
+
+```al
+procedure ProcessTransactionOptimized(TransactionType: Text[20]; Amount: Decimal): Boolean
+begin
+    // Order by frequency - most common first
+    case TransactionType of
+        'SALE':        // 60% of transactions
+            exit(ProcessSaleTransaction(Amount));
+        'PAYMENT':     // 25% of transactions
+            exit(ProcessPaymentTransaction(Amount));
+        'REFUND':      // 10% of transactions
+            exit(ProcessRefundTransaction(Amount));
+        else
+            exit(ProcessUnknownTransaction(TransactionType, Amount));
+    end;
+end;
+```
+
+## Enum vs Text Performance
+
+```al
+// Faster enum-based approach
+procedure ProcessTransactionEnum(TransactionType: Enum "Transaction Type"; Amount: Decimal): Boolean
+begin
+    case TransactionType of
+        TransactionType::Sale:
+            exit(ProcessSaleTransaction(Amount));
+        TransactionType::Payment:
+            exit(ProcessPaymentTransaction(Amount));
+        else
+            exit(false);
+    end;
+end;
+```
+
+## Dictionary Alternative for Large Case Sets
+
+```al
+procedure ProcessWithDictionary(ProcessingType: Text[20]; Data: Text): Text
+var
+    ProcessingFunctions: Dictionary of [Text, Integer];
+    FunctionId: Integer;
+begin
+    ProcessingFunctions.Add('FORMAT', 1);
+    ProcessingFunctions.Add('VALIDATE', 2);
+    ProcessingFunctions.Add('TRANSFORM', 3);
+    
+    if ProcessingFunctions.Get(ProcessingType, FunctionId) then
+        case FunctionId of
+            1: exit(FormatData(Data));
+            2: exit(ValidateData(Data));
+            3: exit(TransformData(Data));
+        end;
+    
+    exit('Unknown processing type');
+end;
+```

package/embedded-knowledge/domains/dean-debug/samples/compound-statements-debugging.md

@@ -0,0 +1,139 @@
+# AL Compound Statements for Enhanced Debugging Examples
+
+## Strategic Breakpoint Placement
+
+### Clear Breakpoint Locations with Compound Statements
+```al
+local procedure ProcessCustomerOrder(var SalesHeader: Record "Sales Header"): Boolean
+var
+    Customer: Record Customer;
+    ValidationResult: Boolean;
+begin
+    // Breakpoint here provides clear entry context
+    if Customer.Get(SalesHeader."Sell-to Customer No.") then begin
+        // Breakpoint here confirms customer retrieval success
+        ValidationResult := ValidateCustomerData(Customer);
+        
+        if ValidationResult then begin
+            // Breakpoint here enters successful validation path
+            if ProcessOrderValidation(SalesHeader) then begin
+                // Breakpoint here confirms order validation success
+                ProcessApprovedOrder(SalesHeader);
+                exit(true);
+            end else begin
+                // Breakpoint here enters order validation failure path
+                LogOrderValidationFailure(SalesHeader."No.");
+                exit(false);
+            end;
+        end else begin
+            // Breakpoint here enters customer validation failure path
+            LogCustomerValidationFailure(Customer."No.");
+            exit(false);
+        end;
+    end else begin
+        // Breakpoint here captures customer not found scenario
+        LogCustomerNotFound(SalesHeader."Sell-to Customer No.");
+        exit(false);
+    end;
+end;
+```
+
+## Exception Context Enhancement
+
+### Clear Exception Boundaries with Compound Statements
+```al
+local procedure ProcessDocumentPosting(var GenJournalLine: Record "Gen. Journal Line")
+var
+    PostingResult: Boolean;
+begin
+    try
+        // Compound block provides clear exception scope
+        if ValidateJournalLine(GenJournalLine) then begin
+            if CheckAccountingPeriod(GenJournalLine."Posting Date") then begin
+                PostingResult := PostJournalLine(GenJournalLine);
+                
+                if PostingResult then begin
+                    // Breakpoint here confirms successful posting
+                    LogSuccessfulPosting(GenJournalLine."Document No.");
+                end else begin
+                    // Breakpoint here captures posting failure
+                    LogPostingFailure(GenJournalLine."Document No.");
+                end;
+            end else begin
+                // Breakpoint here captures period validation failure
+                Error('Accounting period is closed for date %1', GenJournalLine."Posting Date");
+            end;
+        end else begin
+            // Breakpoint here captures journal line validation failure
+            Error('Journal line validation failed');
+        end;
+    except
+        on E: Exception do begin
+            // Breakpoint here provides clear exception context
+            LogPostingException(GenJournalLine."Document No.", E.Message);
+            
+            if E.Message.Contains('period') then begin
+                // Breakpoint here handles period-specific exceptions
+                HandlePeriodException(GenJournalLine);
+            end else begin
+                // Breakpoint here handles general posting exceptions
+                HandleGeneralPostingException(GenJournalLine, E);
+            end;
+        end;
+    end;
+end;
+```
+
+## Loop Debugging with Compound Statements
+
+### Clear Loop Iteration Boundaries
+```al
+local procedure ProcessItemBatch(var ItemBuffer: Record "Item Buffer")
+var
+    ProcessedCount: Integer;
+    ErrorCount: Integer;
+    CurrentItem: Code[20];
+begin
+    ProcessedCount := 0;
+    ErrorCount := 0;
+    
+    if ItemBuffer.FindSet() then begin
+        // Breakpoint here confirms record set found
+        repeat
+            CurrentItem := ItemBuffer."No.";
+            
+            // Breakpoint here shows current item being processed
+            if ValidateItemData(ItemBuffer) then begin
+                // Breakpoint here enters successful validation path
+                try
+                    if UpdateItemCosts(ItemBuffer) then begin
+                        // Breakpoint here confirms successful cost update
+                        ProcessedCount += 1;
+                        LogItemProcessed(CurrentItem);
+                    end else begin
+                        // Breakpoint here captures cost update failure
+                        ErrorCount += 1;
+                        LogItemError(CurrentItem, 'Cost update failed');
+                    end;
+                except
+                    on E: Exception do begin
+                        // Breakpoint here captures processing exceptions
+                        ErrorCount += 1;
+                        LogItemException(CurrentItem, E.Message);
+                    end;
+                end;
+            end else begin
+                // Breakpoint here captures validation failures
+                ErrorCount += 1;
+                LogItemValidationError(CurrentItem);
+            end;
+        until ItemBuffer.Next() = 0;
+        
+        // Breakpoint here provides final processing summary
+        LogBatchSummary(ProcessedCount, ErrorCount);
+    end else begin
+        // Breakpoint here captures empty batch scenario
+        LogEmptyBatch();
+    end;
+end;
+```

package/embedded-knowledge/domains/dean-debug/samples/custom-dimensions.md

@@ -0,0 +1,190 @@
+# Custom Dimension Implementation Examples - AL Code Samples
+
+## Standard Custom Dimensions Pattern
+```al
+codeunit 50110 "Custom Dimensions Examples"
+{
+    // Example 1: Building comprehensive custom dimensions
+    procedure BuildStandardDimensions(): Dictionary of [Text, Text]
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+    begin
+        // Core identification dimensions
+        CustomDimensions.Add('CompanyName', CompanyName());
+        CustomDimensions.Add('UserID', UserId());
+        CustomDimensions.Add('SessionID', Format(SessionId()));
+        
+        // Environment context
+        CustomDimensions.Add('Environment', GetEnvironmentType());
+        CustomDimensions.Add('AppVersion', GetAppVersion());
+        CustomDimensions.Add('BCVersion', GetBCVersion());
+        
+        // Temporal dimensions
+        CustomDimensions.Add('Timestamp', Format(CurrentDateTime, 0, 9));
+        CustomDimensions.Add('Date', Format(Today(), 0, '<Year4>-<Month,2>-<Day,2>'));
+        CustomDimensions.Add('Hour', Format(Time(), 0, '<Hours24>'));
+        
+        exit(CustomDimensions);
+    end;
+
+    // Example 2: Business context dimensions
+    procedure BuildBusinessContextDimensions(CustomerNo: Code[20]; ItemNo: Code[20]): Dictionary of [Text, Text]
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+        Customer: Record Customer;
+        Item: Record Item;
+    begin
+        CustomDimensions := BuildStandardDimensions();
+        
+        // Customer context
+        if Customer.Get(CustomerNo) then begin
+            CustomDimensions.Add('CustomerNo', CustomerNo);
+            CustomDimensions.Add('CustomerGroup', Customer."Customer Posting Group");
+            CustomDimensions.Add('SalespersonCode', Customer."Salesperson Code");
+            CustomDimensions.Add('CountryRegion', Customer."Country/Region Code");
+        end;
+        
+        // Item context
+        if Item.Get(ItemNo) then begin
+            CustomDimensions.Add('ItemNo', ItemNo);
+            CustomDimensions.Add('ItemCategory', Item."Item Category Code");
+            CustomDimensions.Add('ItemType', Format(Item.Type));
+            CustomDimensions.Add('UnitOfMeasure', Item."Base Unit of Measure");
+        end;
+        
+        exit(CustomDimensions);
+    end;
+    
+    // Helper methods
+    local procedure GetEnvironmentType(): Text
+    begin
+        exit('Production'); // Implement actual environment detection
+    end;
+    
+    local procedure GetAppVersion(): Text
+    begin
+        exit('1.0.0.0'); // Implement actual version detection
+    end;
+    
+    local procedure GetBCVersion(): Text
+    begin
+        exit('24.0'); // Implement actual BC version detection
+    end;
+}
+```
+
+## Performance-Optimized Dimension Patterns
+```al
+codeunit 50111 "Optimized Dimension Builder"
+{
+    var
+        CachedDimensions: Dictionary of [Text, Text];
+        LastCacheTime: DateTime;
+        CacheValidityMinutes: Integer;
+
+    // Example 3: Cached dimension building for performance
+    procedure GetCachedStandardDimensions(): Dictionary of [Text, Text]
+    begin
+        if ShouldRefreshCache() then
+            RefreshCachedDimensions();
+            
+        exit(CachedDimensions);
+    end;
+
+    local procedure ShouldRefreshCache(): Boolean
+    begin
+        if LastCacheTime = 0DT then
+            exit(true);
+            
+        exit(CurrentDateTime - LastCacheTime > CacheValidityMinutes * 60000);
+    end;
+
+    local procedure RefreshCachedDimensions()
+    begin
+        CachedDimensions.Clear();
+        
+        // Cache static dimensions that don't change frequently
+        CachedDimensions.Add('CompanyName', CompanyName());
+        CachedDimensions.Add('Environment', 'Production');
+        CachedDimensions.Add('AppVersion', '1.0.0.0');
+        CachedDimensions.Add('BCVersion', '24.0');
+        
+        LastCacheTime := CurrentDateTime;
+    end;
+
+    // Example 4: Conditional dimension building
+    procedure BuildConditionalDimensions(IncludeDetailed: Boolean; IncludePerformance: Boolean): Dictionary of [Text, Text]
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+    begin
+        CustomDimensions := GetCachedStandardDimensions();
+        
+        // Always include dynamic dimensions
+        CustomDimensions.Add('UserID', UserId());
+        CustomDimensions.Add('Timestamp', Format(CurrentDateTime, 0, 9));
+        
+        if IncludeDetailed then begin
+            CustomDimensions.Add('SessionID', Format(SessionId()));
+            CustomDimensions.Add('ClientType', Format(ClientType()));
+            CustomDimensions.Add('LanguageID', Format(GlobalLanguage()));
+        end;
+        
+        if IncludePerformance then begin
+            CustomDimensions.Add('MemoryUsage', 'Unknown');
+            CustomDimensions.Add('CPUTime', 'Unknown');
+        end;
+        
+        exit(CustomDimensions);
+    end;
+}
+```
+
+## Domain-Specific Dimension Patterns
+```al
+codeunit 50112 "Domain Telemetry Dimensions"
+{
+    // Example 5: Sales process dimensions
+    procedure BuildSalesDimensions(SalesHeader: Record "Sales Header"): Dictionary of [Text, Text]
+    var
+        CustomDimensions: Dictionary of [Text, Text];
+        Customer: Record Customer;
+        Salesperson: Record "Salesperson/Purchaser";
+    begin
+        CustomDimensions.Add('Domain', 'Sales');
+        CustomDimensions.Add('DocumentType', Format(SalesHeader."Document Type"));
+        CustomDimensions.Add('DocumentNo', SalesHeader."No.");
+        CustomDimensions.Add('CustomerNo', SalesHeader."Sell-to Customer No.");
+        
+        if Customer.Get(SalesHeader."Sell-to Customer No.") then begin
+            CustomDimensions.Add('CustomerGroup', Customer."Customer Posting Group");
+            CustomDimensions.Add('PaymentTerms', Customer."Payment Terms Code");
+            CustomDimensions.Add('CustomerSize', ClassifyCustomerSize(Customer."Credit Limit (LCY)"));
+        end;
+        
+        if Salesperson.Get(SalesHeader."Salesperson Code") then
+            CustomDimensions.Add('SalespersonName', Salesperson.Name);
+            
+        // Financial dimensions
+        CustomDimensions.Add('CurrencyCode', SalesHeader."Currency Code");
+        CustomDimensions.Add('AmountLCY', Format(SalesHeader."Amount Including VAT"));
+        CustomDimensions.Add('PriceGroup', SalesHeader."Customer Price Group");
+        
+        exit(CustomDimensions);
+    end;
+
+    // Helper function for customer classification
+    local procedure ClassifyCustomerSize(CreditLimit: Decimal): Text
+    begin
+        case true of
+            CreditLimit >= 1000000:
+                exit('Enterprise');
+            CreditLimit >= 100000:
+                exit('Large');
+            CreditLimit >= 10000:
+                exit('Medium');
+            else
+                exit('Small');
+        end;
+    end;
+}
+```