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

package/embedded-knowledge/domains/jordan-bridge/samples/business-process-templates.md

@@ -0,0 +1,434 @@
+# Business Process Templates Sample
+
+## Overview
+This sample demonstrates business process template patterns including configurable workflows, state management, and business rule integration for standardized process execution.
+
+## Basic Process Template Structure
+
+```al
+table 50600 "Business Process Template"
+{
+    fields
+    {
+        field(1; "Template Code"; Code[20]) { }
+        field(2; "Template Name"; Text[100]) { }
+        field(3; "Process Type"; Enum "Business Process Type") { }
+        field(4; "Status"; Enum "Template Status") { }
+        field(5; "Version"; Code[10]) { }
+        field(6; "Configuration Data"; Blob) { }
+        field(7; "Default Values"; Blob) { }
+    }
+
+    keys
+    {
+        key(PK; "Template Code") { Clustered = true; }
+    }
+}
+
+table 50601 "Process Template Step"
+{
+    fields
+    {
+        field(1; "Template Code"; Code[20]) { }
+        field(2; "Step No."; Integer) { }
+        field(3; "Step Name"; Text[100]) { }
+        field(4; "Step Type"; Enum "Process Step Type") { }
+        field(5; "Execution Order"; Integer) { }
+        field(6; "Required"; Boolean) { }
+        field(7; "Condition"; Text[250]) { }
+        field(8; "Configuration"; Blob) { }
+    }
+
+    keys
+    {
+        key(PK; "Template Code", "Step No.") { Clustered = true; }
+        key(ExecutionOrder; "Template Code", "Execution Order") { }
+    }
+}
+```
+
+## Sales Order Process Template
+
+```al
+codeunit 50600 "Sales Order Process Template"
+{
+    procedure ExecuteTemplate(TemplateCode: Code[20]; var SalesHeader: Record "Sales Header"): Boolean
+    var
+        ProcessTemplate: Record "Business Process Template";
+        TemplateStep: Record "Process Template Step";
+        ProcessContext: Record "Process Execution Context";
+    begin
+        if not ProcessTemplate.Get(TemplateCode) then
+            Error('Process template %1 not found', TemplateCode);
+
+        ProcessContext := InitializeProcessContext(TemplateCode, SalesHeader);
+
+        TemplateStep.SetRange("Template Code", TemplateCode);
+        TemplateStep.SetCurrentKey("Template Code", "Execution Order");
+
+        if TemplateStep.FindSet() then
+            repeat
+                if ShouldExecuteStep(TemplateStep, SalesHeader, ProcessContext) then begin
+                    if not ExecuteProcessStep(TemplateStep, SalesHeader, ProcessContext) then begin
+                        HandleStepFailure(TemplateStep, SalesHeader, ProcessContext);
+                        if TemplateStep.Required then
+                            exit(false);
+                    end else
+                        LogStepSuccess(TemplateStep, ProcessContext);
+                end;
+            until TemplateStep.Next() = 0;
+
+        FinalizeProcess(ProcessContext, SalesHeader);
+        exit(true);
+    end;
+
+    local procedure InitializeProcessContext(TemplateCode: Code[20]; SalesHeader: Record "Sales Header"): Record "Process Execution Context"
+    var
+        ProcessContext: Record "Process Execution Context";
+    begin
+        ProcessContext.Init();
+        ProcessContext."Process ID" := CreateGuid();
+        ProcessContext."Template Code" := TemplateCode;
+        ProcessContext."Document Type" := Format(SalesHeader."Document Type");
+        ProcessContext."Document No." := SalesHeader."No.";
+        ProcessContext."Started DateTime" := CurrentDateTime;
+        ProcessContext."User ID" := UserId;
+        ProcessContext.Status := ProcessContext.Status::Running;
+        ProcessContext.Insert(true);
+
+        exit(ProcessContext);
+    end;
+
+    local procedure ExecuteProcessStep(TemplateStep: Record "Process Template Step"; var SalesHeader: Record "Sales Header"; var ProcessContext: Record "Process Execution Context"): Boolean
+    var
+        StepProcessor: Interface "Process Step Processor";
+    begin
+        StepProcessor := GetStepProcessor(TemplateStep."Step Type");
+        exit(StepProcessor.ExecuteStep(TemplateStep, SalesHeader, ProcessContext));
+    end;
+
+    local procedure GetStepProcessor(StepType: Enum "Process Step Type"): Interface "Process Step Processor"
+    var
+        ValidationProcessor: Codeunit "Validation Step Processor";
+        CalculationProcessor: Codeunit "Calculation Step Processor";
+        ApprovalProcessor: Codeunit "Approval Step Processor";
+        NotificationProcessor: Codeunit "Notification Step Processor";
+    begin
+        case StepType of
+            StepType::Validation:
+                exit(ValidationProcessor);
+            StepType::Calculation:
+                exit(CalculationProcessor);
+            StepType::Approval:
+                exit(ApprovalProcessor);
+            StepType::Notification:
+                exit(NotificationProcessor);
+        end;
+    end;
+}
+```
+
+## Approval Process Template
+
+```al
+codeunit 50601 "Approval Process Template"
+{
+    procedure ProcessApprovalWorkflow(DocumentType: Enum "Approval Document Type"; DocumentNo: Code[20]; TemplateCode: Code[20]): Boolean
+    var
+        ApprovalEntry: Record "Approval Entry";
+        ProcessContext: Record "Process Execution Context";
+        WorkflowCompleted: Boolean;
+    begin
+        ProcessContext := InitializeApprovalProcess(DocumentType, DocumentNo, TemplateCode);
+
+        CreateApprovalEntries(DocumentType, DocumentNo, TemplateCode);
+
+        SendApprovalNotifications(DocumentType, DocumentNo);
+
+        // Monitor approval progress
+        WorkflowCompleted := MonitorApprovalProgress(ProcessContext);
+
+        if WorkflowCompleted then
+            FinalizeApprovalProcess(ProcessContext, DocumentType, DocumentNo)
+        else
+            HandleApprovalTimeout(ProcessContext, DocumentType, DocumentNo);
+
+        exit(WorkflowCompleted);
+    end;
+
+    local procedure CreateApprovalEntries(DocumentType: Enum "Approval Document Type"; DocumentNo: Code[20]; TemplateCode: Code[20])
+    var
+        ApprovalTemplate: Record "Approval Process Template";
+        ApprovalStep: Record "Approval Template Step";
+        ApprovalEntry: Record "Approval Entry";
+        UserSetup: Record "User Setup";
+    begin
+        ApprovalStep.SetRange("Template Code", TemplateCode);
+        ApprovalStep.SetCurrentKey("Template Code", "Approval Level");
+
+        if ApprovalStep.FindSet() then
+            repeat
+                if GetApproverForLevel(ApprovalStep."Approval Level", UserSetup) then begin
+                    ApprovalEntry.Init();
+                    ApprovalEntry."Table ID" := GetTableID(DocumentType);
+                    ApprovalEntry."Document No." := DocumentNo;
+                    ApprovalEntry."Sequence No." := GetNextSequenceNo();
+                    ApprovalEntry."Approver ID" := UserSetup."User ID";
+                    ApprovalEntry.Status := ApprovalEntry.Status::Created;
+                    ApprovalEntry."Due Date" := CalcDate(ApprovalStep."Due Date Formula", Today);
+                    ApprovalEntry.Insert(true);
+                end;
+            until ApprovalStep.Next() = 0;
+    end;
+
+    local procedure SendApprovalNotifications(DocumentType: Enum "Approval Document Type"; DocumentNo: Code[20])
+    var
+        ApprovalEntry: Record "Approval Entry";
+        NotificationManagement: Codeunit "Notification Management";
+    begin
+        ApprovalEntry.SetRange("Document No.", DocumentNo);
+        ApprovalEntry.SetRange(Status, ApprovalEntry.Status::Created);
+
+        if ApprovalEntry.FindSet() then
+            repeat
+                NotificationManagement.SendApprovalRequest(ApprovalEntry);
+                ApprovalEntry.Status := ApprovalEntry.Status::"Pending Approval";
+                ApprovalEntry.Modify();
+            until ApprovalEntry.Next() = 0;
+    end;
+}
+```
+
+## Invoice Processing Template
+
+```al
+codeunit 50602 "Invoice Processing Template"
+{
+    procedure ProcessInvoiceWorkflow(var SalesHeader: Record "Sales Header"; TemplateCode: Code[20]): Boolean
+    var
+        InvoiceSteps: Record "Invoice Process Step";
+        ProcessResult: Boolean;
+    begin
+        ValidateInvoiceData(SalesHeader);
+
+        InvoiceSteps.SetRange("Template Code", TemplateCode);
+        InvoiceSteps.SetCurrentKey("Template Code", "Processing Order");
+
+        if InvoiceSteps.FindSet() then
+            repeat
+                ProcessResult := ExecuteInvoiceStep(InvoiceSteps, SalesHeader);
+                UpdateStepStatus(InvoiceSteps, ProcessResult);
+
+                if not ProcessResult and InvoiceSteps."Critical Step" then
+                    exit(false);
+
+            until InvoiceSteps.Next() = 0;
+
+        CompleteInvoiceProcessing(SalesHeader);
+        exit(true);
+    end;
+
+    local procedure ExecuteInvoiceStep(InvoiceStep: Record "Invoice Process Step"; var SalesHeader: Record "Sales Header"): Boolean
+    begin
+        case InvoiceStep."Step Type" of
+            InvoiceStep."Step Type"::"Credit Check":
+                exit(PerformCreditCheck(SalesHeader));
+            InvoiceStep."Step Type"::"Pricing Validation":
+                exit(ValidatePricing(SalesHeader));
+            InvoiceStep."Step Type"::"Tax Calculation":
+                exit(CalculateTaxes(SalesHeader));
+            InvoiceStep."Step Type"::"Discount Application":
+                exit(ApplyDiscounts(SalesHeader));
+            InvoiceStep."Step Type"::"Final Validation":
+                exit(PerformFinalValidation(SalesHeader));
+            InvoiceStep."Step Type"::"Document Generation":
+                exit(GenerateInvoiceDocument(SalesHeader));
+        end;
+
+        exit(false);
+    end;
+
+    local procedure PerformCreditCheck(SalesHeader: Record "Sales Header"): Boolean
+    var
+        Customer: Record Customer;
+        CreditCheck: Codeunit "Credit Management";
+    begin
+        Customer.Get(SalesHeader."Bill-to Customer No.");
+        exit(CreditCheck.CheckCustomerCredit(Customer, SalesHeader."Amount Including VAT"));
+    end;
+
+    local procedure ValidatePricing(var SalesHeader: Record "Sales Header"): Boolean
+    var
+        SalesLine: Record "Sales Line";
+        PriceCalculation: Codeunit "Price Calculation Mgt.";
+    begin
+        SalesLine.SetRange("Document Type", SalesHeader."Document Type");
+        SalesLine.SetRange("Document No.", SalesHeader."No.");
+
+        if SalesLine.FindSet() then
+            repeat
+                PriceCalculation.ApplyPrice(SalesLine);
+                SalesLine.Modify();
+            until SalesLine.Next() = 0;
+
+        exit(true);
+    end;
+}
+```
+
+## Configurable Workflow Engine
+
+```al
+codeunit 50603 "Configurable Workflow Engine"
+{
+    procedure ExecuteConfigurableWorkflow(WorkflowCode: Code[20]; RecordVariant: Variant): Boolean
+    var
+        WorkflowTemplate: Record "Workflow Template";
+        WorkflowInstance: Record "Workflow Instance";
+        ExecutionSuccessful: Boolean;
+    begin
+        if not WorkflowTemplate.Get(WorkflowCode) then
+            Error('Workflow template %1 not found', WorkflowCode);
+
+        WorkflowInstance := CreateWorkflowInstance(WorkflowTemplate, RecordVariant);
+
+        ExecutionSuccessful := ExecuteWorkflowSteps(WorkflowInstance);
+
+        if ExecutionSuccessful then
+            CompleteWorkflowInstance(WorkflowInstance)
+        else
+            HandleWorkflowFailure(WorkflowInstance);
+
+        exit(ExecutionSuccessful);
+    end;
+
+    local procedure ExecuteWorkflowSteps(var WorkflowInstance: Record "Workflow Instance"): Boolean
+    var
+        WorkflowStep: Record "Workflow Template Step";
+        StepExecutor: Codeunit "Workflow Step Executor";
+        StepResult: Boolean;
+        AllStepsSuccessful: Boolean;
+    begin
+        AllStepsSuccessful := true;
+
+        WorkflowStep.SetRange("Template Code", WorkflowInstance."Template Code");
+        WorkflowStep.SetCurrentKey("Template Code", "Execution Order");
+
+        if WorkflowStep.FindSet() then
+            repeat
+                if EvaluateStepCondition(WorkflowStep, WorkflowInstance) then begin
+                    UpdateWorkflowInstanceStatus(WorkflowInstance, 'Processing step: ' + WorkflowStep."Step Name");
+
+                    StepResult := StepExecutor.ExecuteStep(WorkflowStep, WorkflowInstance);
+
+                    LogStepExecution(WorkflowStep, WorkflowInstance, StepResult);
+
+                    if not StepResult then begin
+                        AllStepsSuccessful := false;
+                        if WorkflowStep."Stop on Error" then
+                            exit(false);
+                    end;
+                end;
+            until WorkflowStep.Next() = 0;
+
+        exit(AllStepsSuccessful);
+    end;
+
+    local procedure EvaluateStepCondition(WorkflowStep: Record "Workflow Template Step"; WorkflowInstance: Record "Workflow Instance"): Boolean
+    var
+        ConditionEvaluator: Codeunit "Workflow Condition Evaluator";
+    begin
+        if WorkflowStep.Condition = '' then
+            exit(true);
+
+        exit(ConditionEvaluator.EvaluateCondition(WorkflowStep.Condition, WorkflowInstance));
+    end;
+}
+```
+
+## State Management Template
+
+```al
+codeunit 50604 "Process State Manager"
+{
+    var
+        ProcessStateStack: List of [Text];
+
+    procedure ManageProcessState(var ProcessInstance: Record "Process Instance"; NewState: Enum "Process State"): Boolean
+    var
+        StateTransition: Record "Process State Transition";
+        PreviousState: Enum "Process State";
+    begin
+        PreviousState := ProcessInstance.State;
+
+        if not ValidateStateTransition(PreviousState, NewState) then
+            exit(false);
+
+        // Save current state to stack for potential rollback
+        SaveStateToStack(ProcessInstance, PreviousState);
+
+        // Update process state
+        ProcessInstance.State := NewState;
+        ProcessInstance."State Changed DateTime" := CurrentDateTime;
+        ProcessInstance."State Changed By" := UserId;
+
+        // Log state transition
+        LogStateTransition(ProcessInstance, PreviousState, NewState);
+
+        ProcessInstance.Modify(true);
+
+        // Execute state-specific logic
+        ExecuteStateActions(ProcessInstance, NewState);
+
+        exit(true);
+    end;
+
+    procedure RollbackToLastState(var ProcessInstance: Record "Process Instance"): Boolean
+    var
+        LastState: Text;
+        StateEnum: Enum "Process State";
+    begin
+        if ProcessStateStack.Count = 0 then
+            exit(false);
+
+        LastState := ProcessStateStack.Get(ProcessStateStack.Count);
+        ProcessStateStack.RemoveAt(ProcessStateStack.Count);
+
+        Evaluate(StateEnum, LastState);
+
+        ProcessInstance.State := StateEnum;
+        ProcessInstance."State Changed DateTime" := CurrentDateTime;
+        ProcessInstance."State Changed By" := UserId;
+        ProcessInstance.Modify(true);
+
+        exit(true);
+    end;
+
+    local procedure ValidateStateTransition(FromState: Enum "Process State"; ToState: Enum "Process State"): Boolean
+    var
+        StateTransitionRule: Record "Process State Transition Rule";
+    begin
+        StateTransitionRule.SetRange("From State", FromState);
+        StateTransitionRule.SetRange("To State", ToState);
+        StateTransitionRule.SetRange(Allowed, true);
+
+        exit(not StateTransitionRule.IsEmpty);
+    end;
+
+    local procedure ExecuteStateActions(ProcessInstance: Record "Process Instance"; NewState: Enum "Process State")
+    var
+        StateAction: Record "Process State Action";
+        ActionProcessor: Codeunit "Process Action Processor";
+    begin
+        StateAction.SetRange("Process State", NewState);
+        StateAction.SetRange(Active, true);
+
+        if StateAction.FindSet() then
+            repeat
+                ActionProcessor.ExecuteAction(StateAction, ProcessInstance);
+            until StateAction.Next() = 0;
+    end;
+}
+```
+
+This sample demonstrates comprehensive business process template patterns including configurable workflows, approval processes, invoice processing, workflow engines, and state management for standardized and flexible business process execution.