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

package/embedded-knowledge/domains/alex-architect/samples/api-delegate-operation.md

@@ -0,0 +1,280 @@
+# API Delegate Operation Pattern - AL Code Examples
+
+This sample demonstrates implementing delegate operations for extensible APIs in Business Central.
+
+## Basic Delegate Interface
+
+```al
+// Define delegate operation interface
+interface IDelegateOperation
+{
+    procedure Execute(var Parameters: Dictionary of [Text, Variant]): Boolean;
+    procedure GetName(): Text[50];
+    procedure GetDescription(): Text[250];
+}
+```
+
+## Simple Delegate Implementation
+
+```al
+// Customer validation delegate example
+codeunit 50100 "Customer Validation Delegate" implements IDelegateOperation
+{
+    procedure Execute(var Parameters: Dictionary of [Text, Variant]): Boolean
+    var
+        Customer: Record Customer;
+        CustomerNo: Code[20];
+        ValidationResult: Boolean;
+    begin
+        // Extract parameters
+        if not Parameters.Get('CustomerNo', CustomerNo) then
+            exit(false);
+
+        if not Customer.Get(CustomerNo) then
+            exit(false);
+
+        // Custom validation logic
+        ValidationResult := ValidateCustomerForOperation(Customer);
+        Parameters.Set('IsValid', ValidationResult);
+
+        exit(ValidationResult);
+    end;
+
+    procedure GetName(): Text[50]
+    begin
+        exit('CUSTOMER_VALIDATION');
+    end;
+
+    procedure GetDescription(): Text[250]
+    begin
+        exit('Validates customer eligibility for business operations');
+    end;
+
+    local procedure ValidateCustomerForOperation(Customer: Record Customer): Boolean
+    begin
+        // Business logic for customer validation
+        exit((Customer.Blocked = Customer.Blocked::" ") and (Customer."Credit Limit (LCY)" > 0));
+    end;
+}
+```
+
+## Delegate Registry System
+
+```al
+// Central delegate registry for operation management
+codeunit 50101 "Delegate Registry"
+{
+    var
+        DelegateOperations: Dictionary of [Text, Interface IDelegateOperation];
+
+    procedure RegisterDelegate(OperationType: Text[50]; DelegateOperation: Interface IDelegateOperation)
+    begin
+        DelegateOperations.Set(OperationType, DelegateOperation);
+    end;
+
+    procedure ExecuteDelegate(OperationType: Text[50]; var Parameters: Dictionary of [Text, Variant]): Boolean
+    var
+        DelegateOperation: Interface IDelegateOperation;
+    begin
+        if not DelegateOperations.Get(OperationType, DelegateOperation) then
+            exit(false);
+
+        exit(DelegateOperation.Execute(Parameters));
+    end;
+
+    procedure GetAvailableDelegates(): List of [Text]
+    var
+        AvailableTypes: List of [Text];
+        OperationType: Text;
+    begin
+        foreach OperationType in DelegateOperations.Keys do
+            AvailableTypes.Add(OperationType);
+
+        exit(AvailableTypes);
+    end;
+}
+```
+
+## API with Delegate Operations
+
+```al
+// Sales API that uses delegate operations for extensibility
+page 50100 "Sales API"
+{
+    PageType = API;
+    APIPublisher = 'mycompany';
+    APIGroup = 'sales';
+    APIVersion = 'v1.0';
+    EntityName = 'salesOrder';
+    EntitySetName = 'salesOrders';
+    SourceTable = "Sales Header";
+
+    layout
+    {
+        area(Content)
+        {
+            repeater(Group)
+            {
+                field(documentNo; Rec."No.")
+                {
+                    ApplicationArea = All;
+                }
+                field(customerNo; Rec."Sell-to Customer No.")
+                {
+                    ApplicationArea = All;
+                }
+                field(status; Rec.Status)
+                {
+                    ApplicationArea = All;
+                }
+            }
+        }
+    }
+
+    trigger OnInsertRecord(BelowxRec: Boolean): Boolean
+    var
+        DelegateRegistry: Codeunit "Delegate Registry";
+        Parameters: Dictionary of [Text, Variant];
+        ValidationResult: Boolean;
+    begin
+        // Use delegate for customer validation
+        Parameters.Set('CustomerNo', Rec."Sell-to Customer No.");
+        ValidationResult := DelegateRegistry.ExecuteDelegate('CUSTOMER_VALIDATION', Parameters);
+
+        if not ValidationResult then
+            Error('Customer validation failed through delegate operation');
+
+        exit(true);
+    end;
+}
+```
+
+## Advanced Delegate Chain
+
+```al
+// Chain multiple delegates for complex operations
+codeunit 50102 "Multi-Step Delegate Chain"
+{
+    var
+        DelegateRegistry: Codeunit "Delegate Registry";
+
+    procedure ExecuteChain(ChainName: Text[50]; var Parameters: Dictionary of [Text, Variant]): Boolean
+    var
+        ChainSteps: List of [Text];
+        StepName: Text;
+        StepResult: Boolean;
+    begin
+        ChainSteps := GetChainSteps(ChainName);
+
+        foreach StepName in ChainSteps do begin
+            StepResult := DelegateRegistry.ExecuteDelegate(StepName, Parameters);
+            if not StepResult then begin
+                Parameters.Set('FailedStep', StepName);
+                exit(false);
+            end;
+        end;
+
+        exit(true);
+    end;
+
+    local procedure GetChainSteps(ChainName: Text[50]): List of [Text]
+    var
+        Steps: List of [Text];
+    begin
+        case ChainName of
+            'SALES_VALIDATION':
+                begin
+                    Steps.Add('CUSTOMER_VALIDATION');
+                    Steps.Add('INVENTORY_CHECK');
+                    Steps.Add('CREDIT_APPROVAL');
+                end;
+            'PURCHASE_VALIDATION':
+                begin
+                    Steps.Add('VENDOR_VALIDATION');
+                    Steps.Add('BUDGET_CHECK');
+                    Steps.Add('APPROVAL_WORKFLOW');
+                end;
+        end;
+
+        exit(Steps);
+    end;
+}
+```
+
+## Error Handling Delegate
+
+```al
+// Delegate with comprehensive error handling
+codeunit 50103 "Error Handling Delegate" implements IDelegateOperation
+{
+    procedure Execute(var Parameters: Dictionary of [Text, Variant]): Boolean
+    var
+        ErrorMessages: List of [Text];
+        HasErrors: Boolean;
+    begin
+        HasErrors := false;
+        Clear(ErrorMessages);
+
+        // Perform validation with error collection
+        if not ValidateRequiredParameters(Parameters, ErrorMessages) then
+            HasErrors := true;
+
+        if not ValidateBusinessRules(Parameters, ErrorMessages) then
+            HasErrors := true;
+
+        // Set error information in parameters
+        Parameters.Set('HasErrors', HasErrors);
+        Parameters.Set('ErrorMessages', ErrorMessages);
+
+        exit(not HasErrors);
+    end;
+
+    procedure GetName(): Text[50]
+    begin
+        exit('ERROR_HANDLING');
+    end;
+
+    procedure GetDescription(): Text[250]
+    begin
+        exit('Comprehensive error handling and validation delegate');
+    end;
+
+    local procedure ValidateRequiredParameters(Parameters: Dictionary of [Text, Variant]; var ErrorMessages: List of [Text]): Boolean
+    var
+        IsValid: Boolean;
+    begin
+        IsValid := true;
+
+        if not Parameters.ContainsKey('CustomerNo') then begin
+            ErrorMessages.Add('Missing required parameter: CustomerNo');
+            IsValid := false;
+        end;
+
+        if not Parameters.ContainsKey('Amount') then begin
+            ErrorMessages.Add('Missing required parameter: Amount');
+            IsValid := false;
+        end;
+
+        exit(IsValid);
+    end;
+
+    local procedure ValidateBusinessRules(Parameters: Dictionary of [Text, Variant]; var ErrorMessages: List of [Text]): Boolean
+    var
+        Amount: Decimal;
+        IsValid: Boolean;
+    begin
+        IsValid := true;
+
+        if Parameters.Get('Amount', Amount) then begin
+            if Amount <= 0 then begin
+                ErrorMessages.Add('Amount must be greater than zero');
+                IsValid := false;
+            end;
+        end;
+
+        exit(IsValid);
+    end;
+}
+```
+
+This implementation shows how delegate operations enable flexible, extensible APIs in Business Central while maintaining clean separation of concerns and supporting runtime configuration of business logic.

package/embedded-knowledge/domains/alex-architect/samples/api-fieldset-registration.md

@@ -0,0 +1,200 @@
+# API Fieldset Registration Sample
+
+## Overview
+This sample demonstrates how to implement fieldset registration patterns for dynamic API field management and metadata-driven field selection.
+
+## Basic Fieldset Registration
+
+```al
+codeunit 50100 "API Fieldset Registration"
+{
+    procedure RegisterCustomerFieldset()
+    var
+        FieldsetRegistry: Codeunit "Fieldset Registry";
+        CustomerFieldset: Record "API Fieldset";
+    begin
+        // Register basic customer fieldset
+        CustomerFieldset.Init();
+        CustomerFieldset."Table ID" := Database::Customer;
+        CustomerFieldset."Fieldset Name" := 'BASIC';
+        CustomerFieldset."Field No." := Customer.FieldNo("No.");
+        CustomerFieldset.Insert();
+
+        CustomerFieldset."Field No." := Customer.FieldNo(Name);
+        CustomerFieldset.Insert();
+
+        CustomerFieldset."Field No." := Customer.FieldNo("Phone No.");
+        CustomerFieldset.Insert();
+
+        // Register extended customer fieldset
+        CustomerFieldset."Fieldset Name" := 'EXTENDED';
+        CustomerFieldset."Field No." := Customer.FieldNo("Credit Limit (LCY)");
+        CustomerFieldset.Insert();
+
+        CustomerFieldset."Field No." := Customer.FieldNo("Balance (LCY)");
+        CustomerFieldset.Insert();
+    end;
+}
+```
+
+## Dynamic Field Selection
+
+```al
+codeunit 50101 "Dynamic Field Selection"
+{
+    procedure GetCustomerFields(FieldsetName: Text): List of [Integer]
+    var
+        APIFieldset: Record "API Fieldset";
+        FieldList: List of [Integer];
+    begin
+        APIFieldset.SetRange("Table ID", Database::Customer);
+        APIFieldset.SetRange("Fieldset Name", FieldsetName);
+        if APIFieldset.FindSet() then
+            repeat
+                FieldList.Add(APIFieldset."Field No.");
+            until APIFieldset.Next() = 0;
+
+        exit(FieldList);
+    end;
+
+    procedure ApplyFieldset(var CustomerRec: Record Customer; FieldsetName: Text)
+    var
+        FieldList: List of [Integer];
+        FieldNo: Integer;
+    begin
+        FieldList := GetCustomerFields(FieldsetName);
+        CustomerRec.SetLoadFields();
+
+        foreach FieldNo in FieldList do
+            CustomerRec.AddLoadFields(FieldNo);
+    end;
+}
+```
+
+## Conditional Registration
+
+```al
+codeunit 50102 "Conditional Fieldset Reg"
+{
+    procedure RegisterConditionalFieldset(TableID: Integer; Condition: Text)
+    var
+        ConditionalFieldset: Record "Conditional API Fieldset";
+    begin
+        ConditionalFieldset.Init();
+        ConditionalFieldset."Table ID" := TableID;
+        ConditionalFieldset.Condition := Condition;
+        ConditionalFieldset."Field Selection" := GetFieldsForCondition(TableID, Condition);
+        ConditionalFieldset.Insert();
+    end;
+
+    local procedure GetFieldsForCondition(TableID: Integer; Condition: Text): Text
+    var
+        FieldSelection: Text;
+    begin
+        case Condition of
+            'MINIMAL':
+                FieldSelection := 'No.,Name';
+            'STANDARD':
+                FieldSelection := 'No.,Name,Phone No.,E-Mail';
+            'COMPLETE':
+                FieldSelection := '*';
+        end;
+
+        exit(FieldSelection);
+    end;
+}
+```
+
+## API Integration
+
+```al
+page 50100 "Customer API with Fieldsets"
+{
+    APIPublisher = 'contoso';
+    APIGroup = 'sample';
+    APIVersion = 'v1.0';
+    EntityName = 'customer';
+    EntitySetName = 'customers';
+    SourceTable = Customer;
+
+    trigger OnOpenPage()
+    var
+        FieldsetManager: Codeunit "Dynamic Field Selection";
+        RequestedFieldset: Text;
+    begin
+        // Get fieldset from query parameter
+        RequestedFieldset := GetFieldsetFromRequest();
+        if RequestedFieldset <> '' then
+            FieldsetManager.ApplyFieldset(Rec, RequestedFieldset);
+    end;
+
+    local procedure GetFieldsetFromRequest(): Text
+    var
+        RequestHeaders: HttpHeaders;
+        FieldsetHeader: Text;
+    begin
+        // Extract fieldset preference from request
+        if RequestHeaders.Contains('X-Fieldset') then begin
+            RequestHeaders.GetValues('X-Fieldset', FieldsetHeader);
+            exit(FieldsetHeader);
+        end;
+
+        exit('STANDARD');
+    end;
+}
+```
+
+## Metadata-Driven Configuration
+
+```al
+table 50100 "API Fieldset"
+{
+    fields
+    {
+        field(1; "Table ID"; Integer) { }
+        field(2; "Fieldset Name"; Code[20]) { }
+        field(3; "Field No."; Integer) { }
+        field(4; "Field Name"; Text[100]) { }
+        field(5; Required; Boolean) { }
+        field(6; "Display Order"; Integer) { }
+    }
+
+    keys
+    {
+        key(PK; "Table ID", "Fieldset Name", "Field No.") { Clustered = true; }
+    }
+}
+```
+
+## Performance Considerations
+
+```al
+codeunit 50103 "Fieldset Performance Mgmt"
+{
+    var
+        FieldsetCache: Dictionary of [Text, List of [Integer]];
+
+    procedure GetCachedFieldset(TableID: Integer; FieldsetName: Text): List of [Integer]
+    var
+        CacheKey: Text;
+        FieldList: List of [Integer];
+    begin
+        CacheKey := StrSubstNo('%1_%2', TableID, FieldsetName);
+
+        if FieldsetCache.ContainsKey(CacheKey) then
+            exit(FieldsetCache.Get(CacheKey));
+
+        FieldList := LoadFieldsetFromDatabase(TableID, FieldsetName);
+        FieldsetCache.Set(CacheKey, FieldList);
+
+        exit(FieldList);
+    end;
+
+    procedure ClearCache()
+    begin
+        Clear(FieldsetCache);
+    end;
+}
+```
+
+This sample demonstrates comprehensive fieldset registration patterns including basic registration, dynamic selection, conditional logic, API integration, and performance optimization through caching.