bc-code-intelligence-mcp 1.1.1

package/embedded-knowledge/domains/sam-coder/samples/al-blank-line-organization.md

@@ -0,0 +1,161 @@
+# AL Blank Line Organization - Code Examples
+
+## Good Examples
+
+### Logical Section Separation
+```al
+codeunit 50100 "Customer Management"
+{
+    procedure CreateCustomer(Name: Text[100]; Email: Text[80]): Code[20]
+    var
+        Customer: Record Customer;
+        CustomerNo: Code[20];
+    begin
+        // Input validation section
+        if Name = '' then
+            Error('Customer name cannot be empty');
+        if Email = '' then
+            Error('Customer email cannot be empty');
+
+        // Customer creation section
+        Customer.Init();
+        CustomerNo := NoSeriesMgt.GetNextNo(SalesSetup."Customer Nos.", 0D, true);
+        Customer."No." := CustomerNo;
+        Customer.Name := Name;
+        Customer."E-Mail" := Email;
+
+        // Database operation section
+        Customer.Insert(true);
+
+        // Return result
+        exit(CustomerNo);
+    end;
+}
+```
+
+### Function Group Separation
+```al
+codeunit 50101 "Order Processing"
+{
+    // Validation functions
+    procedure ValidateOrderHeader(var SalesHeader: Record "Sales Header")
+    begin
+        if SalesHeader."Sell-to Customer No." = '' then
+            Error('Customer number is required');
+    end;
+
+    procedure ValidateOrderLines(var SalesLine: Record "Sales Line")
+    begin
+        if SalesLine.Quantity <= 0 then
+            Error('Quantity must be greater than zero');
+    end;
+
+    // Processing functions
+    procedure ProcessOrder(var SalesHeader: Record "Sales Header")
+    begin
+        ValidateOrderHeader(SalesHeader);
+        CalculateTotals(SalesHeader);
+        UpdateInventory(SalesHeader);
+    end;
+
+    procedure CalculateTotals(var SalesHeader: Record "Sales Header")
+    begin
+        SalesHeader.CalcFields("Amount Including VAT");
+    end;
+}
+```
+
+## Bad Examples
+
+### No Logical Separation
+```al
+codeunit 50102 "Bad Organization"
+{
+    procedure ProcessData()
+    var
+        Customer: Record Customer;
+        Item: Record Item;
+        SalesLine: Record "Sales Line";
+    begin
+        if Customer.FindFirst() then
+            Customer.Modify();
+        Item.SetRange(Blocked, false);
+        if Item.FindSet() then
+            repeat
+                Item."Unit Price" := Item."Unit Price" * 1.1;
+                Item.Modify();
+            until Item.Next() = 0;
+        SalesLine.SetRange("Document Type", SalesLine."Document Type"::Order);
+        SalesLine.SetRange("Shipment Date", Today);
+        if SalesLine.FindSet() then
+            SalesLine.DeleteAll();
+        Message('Processing complete');
+    end;
+}
+```
+
+### Excessive Blank Lines
+```al
+codeunit 50103 "Excessive Spacing"
+{
+    procedure BadSpacing()
+    var
+        Customer: Record Customer;
+
+
+        Item: Record Item;
+
+
+        Result: Boolean;
+    begin
+
+
+        Customer.FindFirst();
+
+
+        Item.FindFirst();
+
+
+        Result := true;
+
+
+    end;
+
+
+}
+```
+
+### Missing Function Separation
+```al
+codeunit 50104 "No Function Separation"
+{
+    procedure ValidateCustomer(CustomerNo: Code[20]): Boolean
+    begin
+        exit(CustomerNo <> '');
+    end;
+    procedure CreateItem(ItemNo: Code[20]; Description: Text[100])
+    var
+        Item: Record Item;
+    begin
+        Item.Init();
+        Item."No." := ItemNo;
+        Item.Description := Description;
+        Item.Insert();
+    end;
+    procedure DeleteOrder(OrderNo: Code[20])
+    var
+        SalesHeader: Record "Sales Header";
+    begin
+        SalesHeader.Get(SalesHeader."Document Type"::Order, OrderNo);
+        SalesHeader.Delete(true);
+    end;
+}
+```
+
+## Best Practices
+
+1. **Separate logical sections** within procedures with single blank lines
+2. **Separate functions** with single blank lines between procedure declarations
+3. **Group related functions** together without excessive spacing
+4. **Use consistent spacing** throughout the codeunit
+5. **Avoid excessive blank lines** that disrupt reading flow

package/embedded-knowledge/domains/sam-coder/samples/al-case-action-formatting.md

@@ -0,0 +1,177 @@
+# AL Case Action Formatting - Code Examples
+
+## Good Examples
+
+### Single Statement Actions
+```al
+procedure ProcessOrderStatus(Status: Option Open,Released,Pending)
+begin
+    case Status of
+        Status::Open:
+            Message('Order is open for editing');
+        Status::Released:
+            Message('Order has been released');
+        Status::Pending:
+            Message('Order is pending approval');
+    end;
+end;
+```
+
+### Multi-Statement Actions with Begin-End
+```al
+procedure HandleDocumentType(DocumentType: Option Quote,Order,Invoice)
+var
+    SalesHeader: Record "Sales Header";
+begin
+    case DocumentType of
+        DocumentType::Quote:
+            begin
+                SalesHeader."Document Type" := SalesHeader."Document Type"::Quote;
+                SalesHeader."Quote Valid Until Date" := CalcDate('+30D', Today);
+                SalesHeader.Insert();
+            end;
+        DocumentType::Order:
+            begin
+                SalesHeader."Document Type" := SalesHeader."Document Type"::Order;
+                SalesHeader."Shipment Date" := CalcDate('+7D', Today);
+                SalesHeader.Insert();
+                SendOrderConfirmation(SalesHeader);
+            end;
+        DocumentType::Invoice:
+            begin
+                SalesHeader."Document Type" := SalesHeader."Document Type"::Invoice;
+                SalesHeader."Due Date" := CalcDate('+30D', Today);
+                SalesHeader.Insert();
+                PostInvoice(SalesHeader);
+            end;
+    end;
+end;
+```
+
+### Complex Case with Nested Logic
+```al
+procedure ProcessPaymentMethod(PaymentMethod: Option Cash,CreditCard,BankTransfer,Check)
+var
+    PaymentEntry: Record "Payment Entry";
+    BankAccount: Record "Bank Account";
+begin
+    case PaymentMethod of
+        PaymentMethod::Cash:
+            begin
+                PaymentEntry."Payment Type" := PaymentEntry."Payment Type"::Cash;
+                PaymentEntry."Processing Fee" := 0;
+                PaymentEntry.Insert();
+            end;
+        PaymentMethod::CreditCard:
+            begin
+                PaymentEntry."Payment Type" := PaymentEntry."Payment Type"::"Credit Card";
+                PaymentEntry."Processing Fee" := PaymentEntry.Amount * 0.03;
+                if PaymentEntry."Processing Fee" < 2.50 then
+                    PaymentEntry."Processing Fee" := 2.50;
+                PaymentEntry.Insert();
+            end;
+        PaymentMethod::BankTransfer:
+            begin
+                if BankAccount.Get(PaymentEntry."Bank Account No.") then begin
+                    PaymentEntry."Payment Type" := PaymentEntry."Payment Type"::"Bank Transfer";
+                    PaymentEntry."Processing Fee" := 5.00;
+                    PaymentEntry.Insert();
+                    InitiateBankTransfer(PaymentEntry);
+                end else
+                    Error('Bank account not found');
+            end;
+        PaymentMethod::Check:
+            begin
+                PaymentEntry."Payment Type" := PaymentEntry."Payment Type"::Check;
+                PaymentEntry."Processing Fee" := 1.00;
+                PaymentEntry."Hold Period" := 3;
+                PaymentEntry.Insert();
+            end;
+    end;
+end;
+```
+
+## Bad Examples
+
+### Inconsistent Formatting
+```al
+procedure BadCaseFormatting(Status: Option Open,Released,Pending)
+begin
+    case Status of
+        Status::Open: Message('Order is open');
+        Status::Released:
+        begin
+            Message('Order released');
+            UpdateStatus();
+        end;
+        Status::Pending: begin Message('Pending approval'); RequestApproval(); end;
+    end;
+end;
+```
+
+### Missing Begin-End for Multi-Statement Actions
+```al
+procedure MissingBeginEnd(DocumentType: Option Quote,Order,Invoice)
+var
+    SalesHeader: Record "Sales Header";
+begin
+    case DocumentType of
+        DocumentType::Quote:
+            SalesHeader."Document Type" := SalesHeader."Document Type"::Quote;
+            SalesHeader."Quote Valid Until Date" := CalcDate('+30D', Today);  // Wrong: not in begin-end block
+        DocumentType::Order:
+            SalesHeader."Document Type" := SalesHeader."Document Type"::Order;
+            SalesHeader."Shipment Date" := CalcDate('+7D', Today);  // Wrong: not in begin-end block
+    end;
+end;
+```
+
+### Poor Indentation
+```al
+procedure PoorIndentation(Status: Option Open,Released,Pending)
+begin
+case Status of
+Status::Open:
+Message('Order is open');
+Status::Released:
+begin
+Message('Order released');
+UpdateStatus();
+end;
+Status::Pending:
+begin
+Message('Pending approval');
+RequestApproval();
+end;
+end;
+end;
+```
+
+### Unnecessary Begin-End for Single Statements
+```al
+procedure UnnecessaryBeginEnd(Status: Option Open,Released,Pending)
+begin
+    case Status of
+        Status::Open:
+            begin  // Unnecessary for single statement
+                Message('Order is open');
+            end;
+        Status::Released:
+            begin  // Unnecessary for single statement
+                Message('Order released');
+            end;
+        Status::Pending:
+            begin  // Unnecessary for single statement
+                Message('Pending approval');
+            end;
+    end;
+end;
+```
+
+## Best Practices
+
+1. **Single statements** don't need begin-end blocks
+2. **Multiple statements** must use begin-end blocks
+3. **Consistent indentation** for all case branches
+4. **Align case labels** for visual clarity
+5. **Group related case logic** with appropriate spacing

package/embedded-knowledge/domains/sam-coder/samples/al-lonely-repeat-pattern.md

@@ -0,0 +1,239 @@
+# AL Lonely Repeat Pattern - Code Examples
+
+## Good Examples
+
+### Proper Repeat-Until Loop Structure
+```al
+procedure ProcessCustomerRecords()
+var
+    Customer: Record Customer;
+    ProcessedCount: Integer;
+begin
+    ProcessedCount := 0;
+
+    if Customer.FindSet() then
+        repeat
+            // Process each customer record
+            if not Customer.Blocked then begin
+                Customer."Last Contact Date" := Today;
+                Customer.Modify();
+                ProcessedCount += 1;
+            end;
+        until Customer.Next() = 0;  // Proper until condition
+
+    Message('Processed %1 customer records', ProcessedCount);
+end;
+```
+
+### Repeat Loop with Error Handling and Exit Conditions
+```al
+procedure SafeDataProcessing()
+var
+    DataRecord: Record "Data Processing Queue";
+    MaxAttempts: Integer;
+    AttemptCount: Integer;
+    ProcessingComplete: Boolean;
+begin
+    MaxAttempts := 5;
+    AttemptCount := 0;
+    ProcessingComplete := false;
+
+    if DataRecord.FindSet() then
+        repeat
+            AttemptCount += 1;
+
+            // Process with error handling
+            if TryProcessRecord(DataRecord) then begin
+                ProcessingComplete := true;
+                DataRecord."Processing Status" := DataRecord."Processing Status"::Completed;
+                DataRecord.Modify();
+            end else begin
+                DataRecord."Error Count" += 1;
+                DataRecord.Modify();
+            end;
+
+        until (DataRecord.Next() = 0) or (AttemptCount >= MaxAttempts) or ProcessingComplete;
+
+    if not ProcessingComplete then
+        Error('Data processing failed after %1 attempts', MaxAttempts);
+end;
+```
+
+### Complex Repeat Loop with Multiple Exit Conditions
+```al
+procedure BatchOrderProcessing()
+var
+    SalesHeader: Record "Sales Header";
+    ProcessingStartTime: Time;
+    MaxProcessingTime: Duration;
+    OrdersProcessed: Integer;
+    BatchSize: Integer;
+begin
+    ProcessingStartTime := Time;
+    MaxProcessingTime := 300000;  // 5 minutes in milliseconds
+    OrdersProcessed := 0;
+    BatchSize := 100;
+
+    SalesHeader.SetRange("Document Type", SalesHeader."Document Type"::Order);
+    SalesHeader.SetRange(Status, SalesHeader.Status::Open);
+
+    if SalesHeader.FindSet() then
+        repeat
+            // Process individual order
+            if ProcessSingleOrder(SalesHeader) then
+                OrdersProcessed += 1;
+
+            // Update progress every 10 orders
+            if OrdersProcessed mod 10 = 0 then
+                UpdateProgressIndicator(OrdersProcessed);
+
+        until (SalesHeader.Next() = 0) or
+              (OrdersProcessed >= BatchSize) or
+              (Time - ProcessingStartTime > MaxProcessingTime);
+
+    Message('Batch processing complete. Processed %1 orders', OrdersProcessed);
+end;
+```
+
+### Repeat Loop with Data Validation
+```al
+procedure ValidateAndProcessItems()
+var
+    Item: Record Item;
+    ValidationErrors: Integer;
+    TotalItems: Integer;
+begin
+    ValidationErrors := 0;
+    TotalItems := 0;
+
+    Item.SetRange(Blocked, false);
+
+    if Item.FindSet() then
+        repeat
+            TotalItems += 1;
+
+            // Validate each item
+            if not ValidateItemData(Item) then begin
+                ValidationErrors += 1;
+                LogValidationError(Item."No.");
+            end else begin
+                Item."Last Validation Date" := Today;
+                Item.Modify();
+            end;
+
+        until Item.Next() = 0;
+
+    if ValidationErrors > 0 then
+        Message('Validation complete: %1 errors found out of %2 items', ValidationErrors, TotalItems)
+    else
+        Message('All %1 items validated successfully', TotalItems);
+end;
+```
+
+## Bad Examples
+
+### Lonely Repeat Without Until
+```al
+procedure LonelyRepeat()
+var
+    Customer: Record Customer;
+begin
+    if Customer.FindSet() then
+        repeat
+            Customer."Last Contact Date" := Today;
+            Customer.Modify();
+        // Missing until condition - this creates an infinite loop!
+
+    Message('Processing complete');  // This will never execute
+end;
+```
+
+### Unreachable Until Condition
+```al
+procedure UnreachableUntil()
+var
+    Counter: Integer;
+    MaxCount: Integer;
+begin
+    Counter := 1;
+    MaxCount := 10;
+
+    repeat
+        Message('Processing item %1', Counter);
+        // Counter is never incremented - until condition can never be met
+    until Counter > MaxCount;  // This creates an infinite loop
+end;
+```
+
+### Complex Until Logic That Obscures Termination
+```al
+procedure ObscureTermination()
+var
+    SalesLine: Record "Sales Line";
+    ComplexCondition: Boolean;
+    AnotherCondition: Boolean;
+    YetAnotherCondition: Boolean;
+begin
+    if SalesLine.FindSet() then
+        repeat
+            // Complex processing logic
+            ComplexCondition := (SalesLine.Quantity > 0) and (SalesLine."Unit Price" > 0);
+            AnotherCondition := (SalesLine."Line Discount %" < 50) or (SalesLine.Type = SalesLine.Type::Item);
+            YetAnotherCondition := not ((SalesLine."Shipment Date" = 0D) and (SalesLine."Qty. to Ship" > 0));
+
+            ProcessSalesLine(SalesLine);
+
+        until (SalesLine.Next() = 0) and ComplexCondition and AnotherCondition and YetAnotherCondition;  // Poor: complex until condition
+end;
+```
+
+### No Loop Variable Progression
+```al
+procedure NoProgression()
+var
+    ItemNo: Code[20];
+    Item: Record Item;
+    FoundItem: Boolean;
+begin
+    ItemNo := 'ITEM001';
+    FoundItem := false;
+
+    repeat
+        if Item.Get(ItemNo) then begin
+            FoundItem := true;
+            ProcessItem(Item);
+        end;
+        // ItemNo never changes - if item doesn't exist, this becomes infinite loop
+    until FoundItem;
+end;
+```
+
+### Missing Error Handling for Loop Failures
+```al
+procedure NoErrorHandling()
+var
+    DataRecord: Record "Processing Queue";
+    ProcessingSuccess: Boolean;
+begin
+    ProcessingSuccess := false;
+
+    if DataRecord.FindSet() then
+        repeat
+            // Processing that might fail
+            ProcessRecord(DataRecord);  // No error handling
+            ProcessingSuccess := true;
+        until DataRecord.Next() = 0;
+
+    // No handling for case where processing fails
+    Message('Processing complete');
+end;
+```
+
+## Best Practices
+
+1. **Always pair repeat with until** - never leave repeat statements incomplete
+2. **Ensure until conditions can be met** - validate that loop variables progress toward termination
+3. **Include multiple exit strategies** when appropriate (time limits, error counts, batch sizes)
+4. **Use clear, simple until conditions** that are easy to understand and verify
+5. **Add error handling** to prevent infinite loops from processing failures
+6. **Validate loop progression** to ensure forward movement toward termination condition