bc-code-intelligence-mcp 1.3.3 → 1.3.4

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

@@ -1,280 +0,0 @@
-# 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

@@ -1,200 +0,0 @@
-# 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.