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

package/embedded-knowledge/domains/roger-reviewer/samples/al-begin-end-blocks.md

@@ -0,0 +1,438 @@
+# AL Begin/End Block Structure - Code Examples
+
+## Object Trigger Structure
+
+### Table Trigger Pattern
+```al
+table 50100 "Sales Order Processing"
+{
+    fields
+    {
+        field(1; "Order No."; Code[20])
+        {
+            Caption = 'Order No.';
+        }
+        field(2; "Customer No."; Code[20])
+        {
+            Caption = 'Customer No.';
+            TableRelation = Customer;
+
+            trigger OnValidate()
+            begin
+                if "Customer No." <> '' then begin
+                    Customer.Get("Customer No.");
+                    "Customer Name" := Customer.Name;
+                    ValidateCustomerCredit();
+                end;
+            end;
+        }
+    }
+
+    var
+        Customer: Record Customer;
+
+    trigger OnInsert()
+    begin
+        TestField("Customer No.");
+
+        if "Order No." = '' then begin
+            NoSeriesManagement.InitSeries(GetNoSeriesCode(), xRec."No. Series", 0D, "Order No.", "No. Series");
+        end;
+    end;
+
+    trigger OnModify()
+    begin
+        if xRec."Customer No." <> "Customer No." then begin
+            if OrderLineExists() then begin
+                if not Confirm('Customer changed. Update order lines?') then begin
+                    Error('Customer change cancelled');
+                end;
+                UpdateOrderLines();
+            end;
+        end;
+    end;
+}
+```
+
+### Page Trigger Structure
+```al
+page 50100 "Sales Order Card"
+{
+    PageType = Card;
+    SourceTable = "Sales Order Processing";
+
+    layout
+    {
+        area(Content)
+        {
+            group(General)
+            {
+                field("Order No."; "Order No.")
+                {
+                    ApplicationArea = All;
+
+                    trigger OnAssistEdit()
+                    begin
+                        if AssistEdit(xRec) then begin
+                            CurrPage.Update();
+                        end;
+                    end;
+                }
+            }
+        }
+    }
+
+    actions
+    {
+        area(Processing)
+        {
+            action(ProcessOrder)
+            {
+                Caption = 'Process Order';
+
+                trigger OnAction()
+                begin
+                    if ValidateOrderData() then begin
+                        if ConfirmProcessing() then begin
+                            ProcessOrderLines();
+                            SendConfirmationEmail();
+                            Message('Order processed successfully');
+                        end else begin
+                            Message('Order processing cancelled');
+                        end;
+                    end else begin
+                        Error('Order validation failed');
+                    end;
+                end;
+            }
+        }
+    }
+
+    trigger OnOpenPage()
+    begin
+        SetDefaultFilters();
+        UpdateVisibility();
+
+        if IsNewRecord() then begin
+            InitializeNewOrder();
+        end;
+    end;
+}
+```
+
+## Procedure Organization Patterns
+
+```al
+codeunit 50100 "Order Management"
+{
+    procedure CreateSalesOrder(CustomerNo: Code[20]; OrderDate: Date): Code[20]
+    var
+        SalesHeader: Record "Sales Header";
+        OrderNo: Code[20];
+    begin
+        OrderNo := GetNextOrderNumber();
+
+        SalesHeader.Init();
+        SalesHeader."Document Type" := SalesHeader."Document Type"::Order;
+        SalesHeader."No." := OrderNo;
+        SalesHeader."Sell-to Customer No." := CustomerNo;
+        SalesHeader."Order Date" := OrderDate;
+        SalesHeader.Insert(true);
+
+        exit(OrderNo);
+    end;
+
+    procedure ProcessBulkOrders(var TempOrderBuffer: Record "Order Buffer" temporary)
+    var
+        OrderNo: Code[20];
+        ProcessedCount: Integer;
+        ErrorCount: Integer;
+    begin
+        if TempOrderBuffer.IsEmpty() then begin
+            Message('No orders to process');
+            exit;
+        end;
+
+        TempOrderBuffer.FindSet();
+        repeat
+            if ValidateOrderBuffer(TempOrderBuffer) then begin
+                if CreateOrderFromBuffer(TempOrderBuffer, OrderNo) then begin
+                    ProcessedCount += 1;
+                    TempOrderBuffer."Status" := TempOrderBuffer."Status"::Processed;
+                    TempOrderBuffer."Order No." := OrderNo;
+                end else begin
+                    ErrorCount += 1;
+                    TempOrderBuffer."Status" := TempOrderBuffer."Status"::Error;
+                end;
+            end else begin
+                ErrorCount += 1;
+                TempOrderBuffer."Status" := TempOrderBuffer."Status"::"Validation Error";
+            end;
+
+            TempOrderBuffer.Modify();
+        until TempOrderBuffer.Next() = 0;
+
+        Message('Processing complete. Processed: %1, Errors: %2', ProcessedCount, ErrorCount);
+    end;
+}
+```
+
+## Control Flow Nesting Patterns
+
+```al
+codeunit 50101 "Advanced Control Flow"
+{
+    procedure DetermineShippingMethod(SalesHeader: Record "Sales Header"): Code[10]
+    begin
+        if SalesHeader."Sell-to Country/Region Code" = 'US' then begin
+            if SalesHeader."Order Date" = Today() then begin
+                if SalesHeader.Amount > 1000 then begin
+                    exit('RUSH-PREMIUM');
+                end else begin
+                    exit('RUSH-STANDARD');
+                end;
+            end else begin
+                if SalesHeader.Amount > 500 then begin
+                    exit('DOMESTIC-FREE');
+                end else begin
+                    exit('DOMESTIC-PAID');
+                end;
+            end;
+        end else begin
+            if SalesHeader.Amount > 2000 then begin
+                exit('INTL-EXPRESS');
+            end else begin
+                if GetShippingDistance(SalesHeader."Sell-to Country/Region Code") <= 5000 then begin
+                    exit('INTL-STANDARD');
+                end else begin
+                    exit('INTL-ECONOMY');
+                end;
+            end;
+        end;
+    end;
+
+    procedure ProcessOrderByType(OrderType: Enum "Order Type")
+    begin
+        case OrderType of
+            OrderType::Standard:
+                begin
+                    ValidateInventory();
+                    CreateShipment();
+                    SendConfirmation();
+                end;
+            OrderType::DropShip:
+                begin
+                    ValidateVendor();
+                    CreatePurchaseOrder();
+                    NotifyCustomer();
+                end;
+            OrderType::Transfer:
+                begin
+                    ValidateLocations();
+                    CreateTransferOrder();
+                    UpdateInventory();
+                end;
+            else begin
+                Error('Unsupported order type: %1', OrderType);
+            end;
+        end;
+    end;
+}
+```
+
+## Variable Scope Examples
+
+```al
+codeunit 50102 "Variable Scope Examples"
+{
+    var
+        GlobalCounter: Integer;
+        GlobalCustomer: Record Customer;
+
+    procedure DemonstrateVariableScope()
+    var
+        LocalCounter: Integer;
+        Customer: Record Customer;
+        i: Integer;
+    begin
+        LocalCounter := 0;
+
+        for i := 1 to 10 do begin
+            LocalCounter += 1;
+            GlobalCounter += 1;
+
+            if i mod 2 = 0 then begin
+                Customer.SetRange("No.", Format(i));
+                if Customer.FindFirst() then begin
+                    ProcessCustomer(Customer);
+                end;
+            end;
+        end;
+
+        Message('Local: %1, Global: %2', LocalCounter, GlobalCounter);
+    end;
+
+    procedure ProcessCustomerOrders(CustomerNo: Code[20]; ProcessDate: Date)
+    var
+        SalesHeader: Record "Sales Header";
+        OrderCount: Integer;
+        TotalAmount: Decimal;
+    begin
+        OrderCount := 0;
+        TotalAmount := 0;
+
+        SalesHeader.SetRange("Sell-to Customer No.", CustomerNo);
+        SalesHeader.SetRange("Order Date", ProcessDate);
+
+        if SalesHeader.FindSet() then begin
+            repeat
+                OrderCount += 1;
+                SalesHeader.CalcFields(Amount);
+                TotalAmount += SalesHeader.Amount;
+
+                if SalesHeader.Amount > 1000 then begin
+                    ApplyVIPProcessing(SalesHeader);
+                end;
+
+            until SalesHeader.Next() = 0;
+        end;
+
+        UpdateCustomerStatistics(CustomerNo, OrderCount, TotalAmount);
+    end;
+}
+```
+
+## Exception Handling Patterns
+
+```al
+codeunit 50103 "Exception Handling Examples"
+{
+    procedure SafeOrderProcessing(OrderNo: Code[20]): Boolean
+    var
+        SalesHeader: Record "Sales Header";
+        ProcessingResult: Boolean;
+    begin
+        ProcessingResult := false;
+
+        if SalesHeader.Get(SalesHeader."Document Type"::Order, OrderNo) then begin
+            if ValidateOrderForProcessing(SalesHeader) then begin
+                if ProcessOrderSafely(SalesHeader) then begin
+                    ProcessingResult := true;
+                end;
+            end;
+        end;
+
+        exit(ProcessingResult);
+    end;
+
+    local procedure ProcessOrderSafely(var SalesHeader: Record "Sales Header"): Boolean
+    begin
+        if not Codeunit.Run(Codeunit::"Sales-Post", SalesHeader) then begin
+            LogProcessingError(SalesHeader."No.", GetLastErrorText());
+            ClearLastError();
+            exit(false);
+        end;
+
+        exit(true);
+    end;
+
+    procedure BatchProcessOrders(var TempOrderList: Record "Order Processing Queue" temporary)
+    var
+        ProcessedCount: Integer;
+        ErrorCount: Integer;
+        CurrentOrder: Code[20];
+    begin
+        ProcessedCount := 0;
+        ErrorCount := 0;
+
+        if TempOrderList.FindSet() then begin
+            repeat
+                CurrentOrder := TempOrderList."Order No.";
+
+                if ProcessSingleOrder(CurrentOrder) then begin
+                    ProcessedCount += 1;
+                    TempOrderList.Status := TempOrderList.Status::Completed;
+                end else begin
+                    ErrorCount += 1;
+                    TempOrderList.Status := TempOrderList.Status::Error;
+                    TempOrderList."Error Message" := GetLastErrorText();
+                    ClearLastError();
+                end;
+
+                TempOrderList.Modify();
+
+            until TempOrderList.Next() = 0;
+        end;
+
+        Message('Batch processing complete.\Processed: %1\Errors: %2', ProcessedCount, ErrorCount);
+    end;
+}
+```
+
+## Anti-Pattern Examples
+
+```al
+// ❌ ANTI-PATTERN: Poor block structure
+procedure BadExample()
+var
+    Customer: Record Customer;
+begin
+    // Missing begin/end for multi-statement block
+    if Customer.FindFirst() then
+        Customer.CalcFields(Balance);
+        UpdateCustomerStatus(Customer);  // This always executes!
+
+    // Inconsistent block structure
+    repeat
+        ProcessCustomer();
+    until Customer.Next() = 0;  // Should be in begin/end block
+end;
+
+// ❌ ANTI-PATTERN: Poor variable scope
+procedure BadVariableScope()
+begin
+    if SomeCondition then begin
+        Customer: Record Customer;  // SYNTAX ERROR - can't declare here
+        Customer.FindFirst();
+    end;
+end;
+
+// ✅ CORRECT: Proper block structure
+procedure GoodExample()
+var
+    Customer: Record Customer;
+begin
+    if Customer.FindFirst() then begin
+        Customer.CalcFields(Balance);
+        UpdateCustomerStatus(Customer);
+    end;
+
+    if Customer.FindSet() then begin
+        repeat
+            ProcessCustomer();
+        until Customer.Next() = 0;
+    end;
+end;
+```
+
+## Best Practices Summary
+
+### Block Structure Guidelines
+1. **Always use begin/end** for multi-statement blocks
+2. **Consistent indentation** - use 4 spaces per level
+3. **Clear nesting** - avoid deeply nested structures
+4. **Logical grouping** - group related statements
+5. **Single responsibility** - each block has clear purpose
+
+### Variable Scope Best Practices
+1. **Declare at procedure level** for maximum flexibility
+2. **Initialize variables** before use
+3. **Use meaningful names** indicating scope and purpose
+4. **Minimize global variables** - prefer parameters
+
+### Error Handling Standards
+1. **Check return values** from system functions
+2. **Use ClearLastError()** after handling errors
+3. **Provide meaningful messages** with context
+4. **Implement graceful degradation** where possible
+5. **Log errors appropriately** for troubleshooting

package/embedded-knowledge/domains/roger-reviewer/samples/al-binary-operator-spacing.md

@@ -0,0 +1,255 @@
+# AL Binary Operator Spacing - Code Examples
+
+## Good Examples
+
+### Arithmetic Operators with Proper Spacing
+```al
+procedure CalculateOrderTotals(BaseAmount: Decimal; TaxRate: Decimal; DiscountPct: Decimal): Decimal
+var
+    TaxAmount: Decimal;
+    DiscountAmount: Decimal;
+    NetAmount: Decimal;
+    FinalTotal: Decimal;
+begin
+    // Arithmetic operations with consistent spacing
+    TaxAmount := BaseAmount * TaxRate / 100;
+    DiscountAmount := BaseAmount * DiscountPct / 100;
+    NetAmount := BaseAmount - DiscountAmount;
+    FinalTotal := NetAmount + TaxAmount;
+
+    // Complex calculations with proper spacing
+    FinalTotal := (BaseAmount * (1 - DiscountPct / 100)) * (1 + TaxRate / 100);
+
+    exit(FinalTotal);
+end;
+```
+
+### Comparison Operators with Consistent Spacing
+```al
+procedure ValidateCustomerData(var Customer: Record Customer): Boolean
+var
+    ValidationResult: Boolean;
+begin
+    ValidationResult := true;
+
+    // Comparison operations with proper spacing
+    if Customer."No." = '' then
+        ValidationResult := false;
+
+    if Customer."Credit Limit (LCY)" <= 0 then
+        ValidationResult := false;
+
+    if Customer."Balance (LCY)" >= Customer."Credit Limit (LCY)" then
+        ValidationResult := false;
+
+    if Customer."Last Date Modified" <> Today then
+        Customer."Last Date Modified" := Today;
+
+    // Complex comparison with proper spacing
+    if (Customer."Balance (LCY)" > 0) and (Customer."Credit Limit (LCY)" > 0) then
+        if Customer."Balance (LCY)" / Customer."Credit Limit (LCY)" > 0.8 then
+            Message('Customer approaching credit limit');
+
+    exit(ValidationResult);
+end;
+```
+
+### Logical Operators with Clear Spacing
+```al
+procedure ProcessOrderLogic(var SalesHeader: Record "Sales Header"): Boolean
+var
+    CanProcess: Boolean;
+    Customer: Record Customer;
+begin
+    Customer.Get(SalesHeader."Sell-to Customer No.");
+
+    // Logical operations with proper spacing
+    CanProcess := (SalesHeader.Status = SalesHeader.Status::Open) and
+                  (not Customer.Blocked) and
+                  (SalesHeader."Order Date" <> 0D);
+
+    // Complex logical expressions with clear spacing
+    if (Customer."Credit Limit (LCY)" > 0) and
+       (Customer."Balance (LCY)" < Customer."Credit Limit (LCY)") and
+       ((SalesHeader."Amount Including VAT" + Customer."Balance (LCY)") <= Customer."Credit Limit (LCY)") then
+        CanProcess := true
+    else
+        CanProcess := false;
+
+    // Multiple condition checks with proper spacing
+    if (SalesHeader."Shipment Date" <> 0D) or
+       (SalesHeader."Requested Delivery Date" <> 0D) or
+       (SalesHeader."Promised Delivery Date" <> 0D) then
+        SalesHeader."Has Delivery Date" := true;
+
+    exit(CanProcess);
+end;
+```
+
+### Assignment Operators with Consistent Formatting
+```al
+procedure UpdateCustomerInformation(var Customer: Record Customer; NewCredit: Decimal)
+var
+    PreviousCredit: Decimal;
+    CreditIncrease: Decimal;
+begin
+    // Assignment operations with proper spacing
+    PreviousCredit := Customer."Credit Limit (LCY)";
+    Customer."Credit Limit (LCY)" := NewCredit;
+    CreditIncrease := NewCredit - PreviousCredit;
+
+    // Complex assignments with proper spacing
+    Customer."Credit Available (LCY)" := Customer."Credit Limit (LCY)" - Customer."Balance (LCY)";
+
+    // Multiple assignments maintaining consistency
+    Customer."Last Date Modified" := Today;
+    Customer."Last Time Modified" := Time;
+    Customer."Modified By" := UserId;
+
+    Customer.Modify();
+end;
+```
+
+### Mixed Operators in Complex Expressions
+```al
+procedure CalculateComplexPricing(ItemNo: Code[20]; Quantity: Decimal; CustomerNo: Code[20]): Decimal
+var
+    Item: Record Item;
+    Customer: Record Customer;
+    BasePrice: Decimal;
+    VolumeDiscount: Decimal;
+    CustomerDiscount: Decimal;
+    FinalPrice: Decimal;
+begin
+    Item.Get(ItemNo);
+    Customer.Get(CustomerNo);
+
+    BasePrice := Item."Unit Price";
+
+    // Complex calculations with consistent operator spacing
+    if Quantity >= 100 then
+        VolumeDiscount := 0.15
+    else if Quantity >= 50 then
+        VolumeDiscount := 0.10
+    else if Quantity >= 20 then
+        VolumeDiscount := 0.05
+    else
+        VolumeDiscount := 0.00;
+
+    // Customer type discount calculation
+    if Customer."Customer Price Group" = 'VIP' then
+        CustomerDiscount := 0.20
+    else if Customer."Customer Price Group" = 'PREMIUM' then
+        CustomerDiscount := 0.10
+    else
+        CustomerDiscount := 0.00;
+
+    // Final price calculation with proper spacing
+    FinalPrice := BasePrice * Quantity * (1 - VolumeDiscount) * (1 - CustomerDiscount);
+
+    exit(FinalPrice);
+end;
+```
+
+## Bad Examples
+
+### Cramped Arithmetic Operations
+```al
+procedure BadArithmeticSpacing(Amount: Decimal; Tax: Decimal): Decimal
+var
+    Result: Decimal;
+begin
+    Result:=Amount*Tax/100;  // Bad: no spaces around operators
+    Result:=Amount+Result;   // Bad: no spaces around operators
+    Result:=(Amount*1.1)+Tax-5;  // Bad: inconsistent spacing
+    exit(Result);
+end;
+```
+
+### Inconsistent Comparison Spacing
+```al
+procedure BadComparisonSpacing(Customer: Record Customer): Boolean
+begin
+    if Customer."No."='' then  // Bad: no spaces around =
+        exit(false);
+
+    if Customer."Credit Limit (LCY)" <=0 then  // Bad: no space before <=
+        exit(false);
+
+    if Customer."Balance (LCY)">=  Customer."Credit Limit (LCY)" then  // Bad: inconsistent spacing around >=
+        exit(false);
+
+    exit(true);
+end;
+```
+
+### Poor Logical Operator Spacing
+```al
+procedure BadLogicalSpacing(SalesHeader: Record "Sales Header"): Boolean
+var
+    Customer: Record Customer;
+begin
+    Customer.Get(SalesHeader."Sell-to Customer No.");
+
+    // Bad logical operator spacing
+    if(SalesHeader.Status=SalesHeader.Status::Open)and(not Customer.Blocked)and(SalesHeader."Order Date"<>0D)then  // Bad: no spaces
+        exit(true);
+
+    if (Customer."Credit Limit (LCY)">0)and (Customer."Balance (LCY)"<Customer."Credit Limit (LCY)")then  // Bad: inconsistent spacing
+        exit(true);
+
+    exit(false);
+end;
+```
+
+### Cramped Assignment Operations
+```al
+procedure BadAssignmentSpacing(var Customer: Record Customer)
+var
+    NewCredit: Decimal;
+begin
+    NewCredit:=5000;  // Bad: no spaces around :=
+    Customer."Credit Limit (LCY)":=NewCredit;  // Bad: no spaces around :=
+    Customer."Credit Available (LCY)":=Customer."Credit Limit (LCY)"-Customer."Balance (LCY)";  // Bad: no spaces around operators
+end;
+```
+
+### Mixed Spacing Inconsistency
+```al
+procedure InconsistentSpacing(Amount: Decimal; Discount: Decimal): Decimal
+var
+    Result: Decimal;
+begin
+    Result := Amount * (1-Discount/100);  // Bad: inconsistent spacing (some operators have spaces, others don't)
+    Result:= Result+10;  // Bad: space only on one side of :=
+    Result=Result *1.1;  // Bad: wrong assignment operator and poor spacing
+
+    if Result> 1000 then  // Bad: space only on one side of >
+        Result := Result- 50;  // Bad: space only on one side of -
+
+    exit(Result);
+end;
+```
+
+### Extremely Cramped Complex Expressions
+```al
+procedure CrampedComplexExpressions(Item: Record Item; Qty: Decimal; Customer: Record Customer): Decimal
+var
+    Price: Decimal;
+begin
+    Price:=Item."Unit Price"*Qty*(1-GetVolumeDiscount(Qty)/100)*(1-GetCustomerDiscount(Customer."No.")/100);  // Bad: no spacing in complex expression
+
+    if(Item."Unit Price">0)and(Qty>0)and(Customer."Credit Limit (LCY)">Customer."Balance (LCY)")then  // Bad: cramped logical expression
+        Price:=Price*1.1;  // Bad: no spaces
+
+    exit(Price);
+end;
+```
+
+## Best Practices
+
+1. **Single space before and after** all binary operators (+, -, *, /, =, <>, <, >, <=, >=, :=)
+2. **Consistent spacing** throughout all expressions and assignments
+3. **Clear separation** in complex expressions with parentheses and spacing
+4. **Maintain spacing** in multi-line expressions for readability
+5. **Use consistent patterns** across entire codebase for professional appearance