Flexbase and Azure Logic Apps Integration

🚀 Overview

FlexBase provides seamless integration with Azure Logic Apps through its REST client architecture, enabling enterprise applications to leverage Azure's powerful workflow automation capabilities. This integration allows developers to orchestrate complex business processes, integrate with external systems, and implement sophisticated workflows without writing complex integration code.

🏗️ Architecture Overview

FlexBase REST Client Pattern

FlexBase implements a clean, maintainable pattern for Azure Logic Apps integration:

┌─────────────────────────────────────┐
│ Controller Layer (API Endpoint)     │ ← REST API entry point
├─────────────────────────────────────┤
│ Handler Layer (Business Logic)      │ ← Command processing
├─────────────────────────────────────┤
│ REST Client Layer (Integration)     │ ← Azure Logic Apps communication
├─────────────────────────────────────┤
│ Azure Logic Apps (Workflow)         │ ← External workflow processing
└─────────────────────────────────────┘

Key Components

Controller - REST API endpoint for external access
Handler - Business logic orchestration and command processing
REST Client - Azure Logic Apps communication layer
Azure Logic Apps - External workflow processing and automation

🔧 Implementation Example: Logic App Basic Call

1. Controller Layer - API Endpoint

// MiscsController_DemonstrateLogicAppCallBasic.cs
public partial class MiscsController : FlexControllerBridge<MiscsController>
{
    [HttpPost]
    [Route("DemonstrateLogicAppCallBasic")]
    [ProducesResponseType(typeof(BadRequestResult), 400)]
    [ProducesResponseType(typeof(string), 201)]
    public async Task<IActionResult> DemonstrateLogicAppCallBasic([FromBody]DemonstrateLogicAppCallBasicDto dto)
    {
        return await RunService(201, dto, _processMiscsService.DemonstrateLogicAppCallBasic);
    }
}

Key Features:

RESTful API - Standard HTTP POST endpoint
Type Safety - Strongly-typed DTO parameters
Error Handling - Built-in HTTP status code management
FlexBase Integration - Uses FlexControllerBridge for consistent behavior

2. Handler Layer - Business Logic

// DemonstrateLogicAppCallBasicHandler.cs
public partial class DemonstrateLogicAppCallBasicHandler : IDemonstrateLogicAppCallBasicHandler
{
    protected readonly ILogger<DemonstrateLogicAppCallBasicHandler> _logger;
    protected readonly IFlexHost _flexHost;
    protected MiscsRESTClient _restClient;

    public virtual async Task Execute(DemonstrateLogicAppCallBasicCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        // Convert command to request parameters
        DemonstrateLogicAppCallBasicRequestDto requestParams = new DemonstrateLogicAppCallBasicRequestDto
        {
            // Map command data to request DTO
        };

        // Call Azure Logic App
        var response = await _restClient.DemonstrateLogicAppCallBasic(requestParams);

        // Process response
        var jsonContent = await response.Content.ReadAsStringAsync();
        _logger.LogInformation(jsonContent);

        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Key Features:

Command Pattern - Encapsulates business operations
Dependency Injection - Clean dependency management
Error Handling - Comprehensive logging and error management
Event Publishing - Domain event integration

3. REST Client Layer - Azure Integration

// MiscsRESTClient.cs
public partial class MiscsRESTClient : LogicAppDemonstrationRESTClientBase, IFlexRESTClientService
{
    public async Task<HttpResponseMessage> DemonstrateLogicAppCallBasic(DemonstrateLogicAppCallBasicRequestDto model)
    {
        var httpClient = _httpClientFactory.CreateClient(LogicAppDemonstrationRESTClientMaster.Name);

        var serializedModel = JsonConvert.SerializeObject(model);

        var request = new HttpRequestMessage(
            HttpMethod.Post,
            $"workflows/{workflowId}/triggers/When_a_HTTP_request_is_received/paths/invoke?api-version=2016-10-01&sp=%2Ftriggers%2FWhen_a_HTTP_request_is_received%2Frun&sv=1.0&sig={signature}");
        
        request.Content = new StringContent(serializedModel, Encoding.UTF8, "application/json");
        request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

        var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);

        return await response.HandleHttpResponse();
    }
}

Key Features:

HTTP Client Factory - Managed HTTP client lifecycle
JSON Serialization - Automatic object serialization
Authentication - Built-in Azure Logic Apps authentication
Error Handling - FlexBase HTTP response handling

🎯 Azure Logic Apps Integration Scenarios

1. HTTP Request Trigger (Basic)

Use Case: Simple workflow initiation via REST API call

// Basic HTTP trigger scenario
public async Task<HttpResponseMessage> TriggerBasicWorkflow(WorkflowRequestDto request)
{
    var httpClient = _httpClientFactory.CreateClient("LogicAppClient");
    
    var request = new HttpRequestMessage(
        HttpMethod.Post,
        $"workflows/{workflowId}/triggers/manual/paths/invoke?api-version=2016-10-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig={signature}");
    
    request.Content = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
    
    return await httpClient.SendAsync(request);
}

Business Scenarios:

Order Processing - Trigger order fulfillment workflow
Document Generation - Generate reports and documents
Notification Sending - Send emails, SMS, or push notifications
Data Validation - Validate and process incoming data

2. Azure Storage Queue Trigger

Use Case: Process messages from Azure Storage Queues

// FlexBase Handler for Azure Storage Queue
public class StorageQueueHandler : IStorageQueueHandler
{
    private readonly QueueClient _queueClient;
    private readonly ILogger<StorageQueueHandler> _logger;
    
    public StorageQueueHandler(IConfiguration configuration, ILogger<StorageQueueHandler> logger)
    {
        var connectionString = configuration.GetConnectionString("StorageAccount");
        var queueName = configuration["StorageQueue:QueueName"];
        _queueClient = new QueueClient(connectionString, queueName);
        _logger = logger;
    }
    
    public async Task Execute(ProcessQueueMessageCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        // Send message to Azure Storage Queue
        // Logic App will automatically trigger when message arrives
        var message = new QueueMessageDto
        {
            MessageId = cmd.MessageId,
            Data = cmd.Data,
            Priority = cmd.Priority,
            Timestamp = DateTime.UtcNow
        };
        
        await _queueClient.SendMessageAsync(JsonConvert.SerializeObject(message));
        
        _logger.LogInformation($"Message sent to queue: {cmd.MessageId}");
        
        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Business Scenarios:

Batch Processing - Process large volumes of data
Asynchronous Workflows - Decouple processing from user requests
Retry Logic - Handle failed operations with automatic retries
Load Balancing - Distribute workload across multiple instances

3. Event Grid Trigger

Use Case: React to Azure Event Grid events

// FlexBase Handler for Event Grid
public class EventGridHandler : IEventGridHandler
{
    private readonly EventGridPublisherClient _eventGridClient;
    private readonly ILogger<EventGridHandler> _logger;
    
    public EventGridHandler(IConfiguration configuration, ILogger<EventGridHandler> logger)
    {
        var eventGridEndpoint = configuration["EventGrid:Endpoint"];
        var eventGridKey = configuration["EventGrid:Key"];
        _eventGridClient = new EventGridPublisherClient(
            new Uri(eventGridEndpoint), 
            new AzureKeyCredential(eventGridKey));
        _logger = logger;
    }
    
    public async Task Execute(PublishEventCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        var events = new List<EventGridEvent>
        {
            new EventGridEvent(cmd.Subject, cmd.EventType, "1.0", cmd.EventData)
        };
        
        await _eventGridClient.SendEventsAsync(events);
        
        _logger.LogInformation($"Event published: {cmd.EventType}");
        
        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Business Scenarios:

Real-time Processing - React to system events immediately
Integration Events - Communicate between microservices
Audit Logging - Track system changes and user actions
Compliance - Meet regulatory requirements with event tracking

4. Azure Service Bus Trigger

Use Case: Process messages from Azure Service Bus

// FlexBase Handler for Azure Service Bus
public class ServiceBusHandler : IServiceBusHandler
{
    private readonly ServiceBusClient _serviceBusClient;
    private readonly ILogger<ServiceBusHandler> _logger;
    
    public ServiceBusHandler(IConfiguration configuration, ILogger<ServiceBusHandler> logger)
    {
        var connectionString = configuration.GetConnectionString("ServiceBus");
        var queueName = configuration["ServiceBus:QueueName"];
        _serviceBusClient = new ServiceBusClient(connectionString);
        _logger = logger;
    }
    
    public async Task Execute(SendServiceBusMessageCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        var sender = _serviceBusClient.CreateSender(cmd.QueueName);
        
        var serviceBusMessage = new ServiceBusMessage(JsonConvert.SerializeObject(cmd.MessageData))
        {
            MessageId = cmd.MessageId,
            Subject = cmd.Subject,
            ContentType = "application/json"
        };
        
        await sender.SendMessageAsync(serviceBusMessage);
        
        _logger.LogInformation($"Message sent to Service Bus: {cmd.MessageId}");
        
        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Business Scenarios:

Enterprise Messaging - Reliable message delivery
Transaction Processing - Ensure message processing consistency
Dead Letter Handling - Manage failed message processing
Topic Subscriptions - Publish-subscribe messaging patterns

🔄 Advanced Integration Patterns

1. Multi-Step Workflow Orchestration with FlexBase Handlers and Subscribers

FlexBase provides a sophisticated event-driven architecture for complex workflows using Handlers and Subscribers that seamlessly integrate with Azure Logic Apps for business logic execution. This pattern ensures resilience, scalability, and maintainability while leveraging the full power of Azure Logic Apps.

Example: Order Processing Workflow with Azure Logic Apps Integration

💡 Key Insight: Each step in the workflow calls Azure Logic Apps to execute complex business logic, while FlexBase handles the orchestration, resilience, and event flow. You get the best of both worlds - FlexBase's robust architecture and Azure Logic Apps' powerful workflow capabilities.

// Step 1: Command Handler - Process Payment (Synchronous)
public class ProcessPaymentHandler : IProcessPaymentHandler
{
    private readonly ILogger<ProcessPaymentHandler> _logger;
    private readonly PaymentProcessingRESTClient _restClient;
    
    public ProcessPaymentHandler(ILogger<ProcessPaymentHandler> logger, PaymentProcessingRESTClient restClient)
    {
        _logger = logger;
        _restClient = restClient;
    }
    
    public async Task Execute(ProcessPaymentCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        // Validate payment data
        if (!ValidatePaymentData(cmd.PaymentData))
        {
            throw new BusinessException("Invalid payment data");
        }
        
        // Process payment via Azure Logic Apps - Complex business logic executed in Logic Apps
        // Logic Apps handles: payment gateway selection, fraud detection, retry logic, compliance checks
        var response = await _restClient.ProcessPayment(cmd.PaymentData);
        
        if (response.IsSuccessStatusCode)
        {
            _logger.LogInformation($"Payment processed successfully for Order: {cmd.OrderId}");
            
            // Fire event to trigger next step - FlexBase handles the orchestration
            await this.Fire("PAYMENT_SUCCESS", serviceBusContext);
        }
        else
        {
            _logger.LogError($"Payment failed for Order: {cmd.OrderId}");
            await this.Fire("PAYMENT_FAILED", serviceBusContext);
        }
    }
}

// Step 2: Event Subscriber - Update Inventory (Asynchronous)
public class UpdateInventorySubscriber : IUpdateInventorySubscriber
{
    private readonly ILogger<UpdateInventorySubscriber> _logger;
    private readonly InventoryRESTClient _restClient;
    
    public UpdateInventorySubscriber(ILogger<UpdateInventorySubscriber> logger, InventoryRESTClient restClient)
    {
        _logger = logger;
        _restClient = restClient;
    }
    
    public async Task Execute(PaymentProcessedEvent @event, IFlexServiceBusContext serviceBusContext)
    {
        _logger.LogInformation($"Updating inventory for Order: {@event.OrderId}");
        
        // Update inventory via Azure Logic Apps - Complex business logic executed in Logic Apps
        // Logic Apps handles: stock validation, allocation, reservation, low-stock alerts, supplier notifications
        var response = await _restClient.UpdateInventory(@event.OrderItems);
        
        if (response.IsSuccessStatusCode)
        {
            _logger.LogInformation($"Inventory updated successfully for Order: {@event.OrderId}");
            
            // Fire event to trigger next step - FlexBase handles the orchestration
            await this.Fire("INVENTORY_UPDATED", serviceBusContext);
        }
        else
        {
            _logger.LogError($"Inventory update failed for Order: {@event.OrderId}");
            await this.Fire("INVENTORY_UPDATE_FAILED", serviceBusContext);
        }
    }
}

// Step 3: Event Subscriber - Send Notifications (Asynchronous)
public class SendNotificationSubscriber : ISendNotificationSubscriber
{
    private readonly ILogger<SendNotificationSubscriber> _logger;
    private readonly NotificationRESTClient _restClient;
    
    public SendNotificationSubscriber(ILogger<SendNotificationSubscriber> logger, NotificationRESTClient restClient)
    {
        _logger = logger;
        _restClient = restClient;
    }
    
    public async Task Execute(InventoryUpdatedEvent @event, IFlexServiceBusContext serviceBusContext)
    {
        _logger.LogInformation($"Sending notifications for Order: {@event.OrderId}");
        
        // Send notifications via Azure Logic Apps - Complex business logic executed in Logic Apps
        // Logic Apps handles: email template selection, personalization, multi-channel delivery, delivery tracking
        var response = await _restClient.SendOrderConfirmation(@event.OrderId, @event.CustomerEmail);
        
        if (response.IsSuccessStatusCode)
        {
            _logger.LogInformation($"Notifications sent successfully for Order: {@event.OrderId}");
        }
        else
        {
            _logger.LogError($"Notification sending failed for Order: {@event.OrderId}");
        }
    }
}

2. Built-in Resilience in FlexBase Handlers

FlexBase provides built-in resilience through NServiceBus integration, eliminating the need for custom retry logic:

Automatic Retry Features:

Exponential Backoff: Automatic retry with increasing delays
Dead Letter Queue: Failed messages moved to DLQ after max retries
Circuit Breaker: Automatic circuit breaking on repeated failures
Message Durability: Messages persisted until successfully processed
Idempotency: Safe to retry operations without side effects

// FlexBase handles resilience automatically - no custom retry code needed
public class ProcessPaymentHandler : IProcessPaymentHandler
{
    public async Task Execute(ProcessPaymentCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        // FlexBase automatically handles:
        // - Retry on transient failures
        // - Exponential backoff
        // - Dead letter queue on permanent failures
        // - Message durability and ordering
        
        var response = await _restClient.ProcessPayment(cmd.PaymentData);
        
        // Business logic only - resilience is handled by FlexBase
        if (response.IsSuccessStatusCode)
        {
            await this.Fire("PAYMENT_SUCCESS", serviceBusContext);
        }
    }
}

3. FlexBase + Azure Logic Apps: The Perfect Partnership

Why This Combination is Powerful:

FlexBase Handles: Architecture, resilience, event orchestration, scaling, testing
Azure Logic Apps Handles: Complex business logic, integrations, visual workflows, connectors
Result: You get enterprise-grade architecture with powerful business logic execution

What You Can Build with This Partnership:

Complex Workflows: Multi-step business processes with visual design
System Integrations: Connect to 400+ services without custom code
Data Transformations: Visual data mapping and transformation
Conditional Logic: Branching workflows based on business rules
Error Handling: Sophisticated retry and compensation logic
Monitoring: Built-in workflow monitoring and analytics

4. FlexBase Handler and Subscriber Pattern

FlexBase implements a sophisticated Command-Query-Event pattern that provides clean separation of concerns and automatic resilience:

Architecture Flow:

┌─────────────────────────────────────────────────────────────────┐
│ 1. Command Handler (Synchronous)                               │
│    - ProcessPaymentHandler                                     │
│    - Validates data & calls Azure Logic Apps                   │
│    - Fires events on success/failure                          │
├─────────────────────────────────────────────────────────────────┤
│ 2. Event Subscribers (Asynchronous)                           │
│    - UpdateInventorySubscriber (triggered by PaymentProcessedEvent) │
│    - SendNotificationSubscriber (triggered by InventoryUpdatedEvent) │
│    - Each subscriber calls Azure Logic Apps independently     │
└─────────────────────────────────────────────────────────────────┘

Key Benefits:

Separation of Concerns: Each handler/subscriber has a single responsibility
Automatic Resilience: NServiceBus handles retries, dead letter queues, and circuit breakers
Eventual Consistency: Subscribers process events asynchronously
Scalability: Each component can be scaled independently
Testability: Each handler/subscriber can be tested in isolation
Maintainability: Easy to add/remove workflow steps

Event Flow Example:

// 1. Command Handler fires event
await this.Fire("PAYMENT_SUCCESS", serviceBusContext);

// 2. Event automatically triggers subscribers
// - UpdateInventorySubscriber.Execute() is called
// - SendNotificationSubscriber.Execute() is called after inventory update

// 3. Each subscriber can fire its own events
await this.Fire("INVENTORY_UPDATED", serviceBusContext);

🚀 The Power of FlexBase + Azure Logic Apps: Do Anything, Compromise Nothing

You Don't Have to Choose Between Architecture and Business Logic

Many developers face a dilemma: use a robust enterprise framework (and lose flexibility) or use powerful business logic tools (and lose architectural benefits). With FlexBase + Azure Logic Apps, you get both.

🎯 What This Means for You:

✅ Keep Your Azure Logic Apps Investment

Visual Workflows: Continue using the drag-and-drop designer
400+ Connectors: Access all existing Logic Apps connectors
No Code Changes: Your existing Logic Apps workflows work unchanged
Familiar Tools: Use the Azure portal and Logic Apps designer

✅ Get Enterprise Architecture Benefits

Resilience: Automatic retry, dead letter queues, circuit breakers
Scalability: Scale handlers and subscribers independently
Testing: Unit test each component in isolation
Monitoring: Comprehensive logging and health checks
Security: Built-in authentication and authorization

✅ Build Anything You Can Imagine

E-commerce: Order processing, inventory management, payment flows
CRM Integration: Lead management, customer onboarding, support workflows
Document Processing: PDF generation, approval workflows, compliance
IoT: Device data processing, alerting, automated responses
Financial: Payment processing, fraud detection, reconciliation

🔄 Real-World Example: E-commerce Order Processing

// Your existing Azure Logic Apps workflows remain unchanged
// FlexBase just orchestrates them with enterprise-grade reliability

// 1. Payment Processing Logic App
// - Handles multiple payment gateways
// - Fraud detection algorithms
// - Compliance checks
// - Retry logic for failed payments

// 2. Inventory Management Logic App  
// - Stock validation
// - Allocation algorithms
// - Supplier notifications
// - Low-stock alerts

// 3. Notification Logic App
// - Email template selection
// - Personalization engine
// - Multi-channel delivery
// - Delivery tracking

// FlexBase orchestrates these with:
// - Event-driven architecture
// - Automatic resilience
// - Independent scaling
// - Comprehensive monitoring

🛠️ FlexBase Integration Benefits

1. Clean Architecture

Separation of Concerns - Clear boundaries between layers
Dependency Injection - Easy testing and maintenance
Type Safety - Compile-time validation throughout
Error Handling - Consistent error management patterns

2. Scalability

Horizontal Scaling - Stateless handlers can be scaled independently
Load Balancing - Multiple instances can handle increased load
Async Processing - Non-blocking operations for better performance
Resource Management - Efficient HTTP client lifecycle management

3. Maintainability

Consistent Patterns - Same structure across all integrations
Easy Testing - Each layer can be tested independently
Configuration Management - Centralized configuration for all integrations
Logging and Monitoring - Built-in logging and monitoring capabilities

4. Enterprise Features

Authentication - Built-in Azure authentication support
Security - Secure communication with Azure services
Compliance - Audit trails and compliance reporting
Monitoring - Health checks and performance monitoring

🚀 Best Practices

1. Error Handling

// Comprehensive error handling
public async Task<HttpResponseMessage> ExecuteWithErrorHandling<T>(T request)
{
    try
    {
        var response = await _restClient.ExecuteLogicApp(request);
        
        if (!response.IsSuccessStatusCode)
        {
            _logger.LogWarning($"Logic App returned {response.StatusCode}: {await response.Content.ReadAsStringAsync()}");
        }
        
        return response;
    }
    catch (HttpRequestException ex)
    {
        _logger.LogError(ex, "HTTP request failed");
        return new HttpResponseMessage(HttpStatusCode.ServiceUnavailable);
    }
    catch (TaskCanceledException ex)
    {
        _logger.LogError(ex, "Request timeout");
        return new HttpResponseMessage(HttpStatusCode.RequestTimeout);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Unexpected error occurred");
        return new HttpResponseMessage(HttpStatusCode.InternalServerError);
    }
}

2. Configuration Management

// Configuration-driven integration
public class LogicAppConfiguration
{
    public string BaseUrl { get; set; }
    public string WorkflowId { get; set; }
    public string Signature { get; set; }
    public int TimeoutSeconds { get; set; } = 30;
    public int MaxRetries { get; set; } = 3;
    public bool EnableLogging { get; set; } = true;
}

3. Performance Optimization

// Performance-optimized HTTP client
public class OptimizedLogicAppClient
{
    private readonly HttpClient _httpClient;
    
    public OptimizedLogicAppClient(IHttpClientFactory httpClientFactory)
    {
        _httpClient = httpClientFactory.CreateClient("LogicAppClient");
        
        // Configure for optimal performance
        _httpClient.Timeout = TimeSpan.FromSeconds(30);
        _httpClient.DefaultRequestHeaders.Add("User-Agent", "FlexBase-Client/1.0");
    }
    
    public async Task<HttpResponseMessage> ExecuteOptimized<T>(T request)
    {
        // Use connection pooling and keep-alive
        var response = await _httpClient.PostAsJsonAsync("workflows/execute", request);
        return response;
    }
}

🎯 Key Takeaways

FlexBase + Azure Logic Apps = Powerful Integration

Clean Architecture - Clear separation of concerns with FlexBase patterns
Multiple Triggers - Support for HTTP, Storage Queue, Event Grid, and Service Bus
Enterprise Features - Authentication, security, monitoring, and compliance
Scalability - Horizontal scaling and load balancing capabilities
Maintainability - Consistent patterns and easy testing

Business Value

Rapid Development - Quick integration with Azure Logic Apps
Reliable Processing - Robust error handling and retry logic
Cost Effective - Pay-per-use Azure Logic Apps pricing
Future Proof - Easy to extend and modify as requirements change

🔄 Common Azure Logic Apps Flow Examples

1. Email Notification Flow

Business Scenario: Send automated email notifications for order confirmations, password resets, or system alerts.

// FlexBase Handler for Email Notification
public class EmailNotificationHandler : IEmailNotificationHandler
{
    private readonly ILogger<EmailNotificationHandler> _logger;
    private readonly EmailNotificationRESTClient _restClient;
    
    public EmailNotificationHandler(ILogger<EmailNotificationHandler> logger, EmailNotificationRESTClient restClient)
    {
        _logger = logger;
        _restClient = restClient;
    }
    
    public async Task Execute(SendEmailCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        var emailRequest = new EmailNotificationRequestDto
        {
            To = cmd.RecipientEmail,
            Subject = cmd.Subject,
            Body = cmd.MessageBody,
            TemplateId = cmd.TemplateId
        };

        var response = await _restClient.SendEmailNotification(emailRequest);
        
        if (response.IsSuccessStatusCode)
        {
            _logger.LogInformation($"Email sent successfully to {cmd.RecipientEmail}");
        }
        
        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Azure Logic Apps Flow:

HTTP Request Trigger - Receive email request from FlexBase
Condition - Check if email template exists
Get Template - Retrieve email template from storage
Send Email - Send email via Office 365 or SendGrid
Log Result - Log success/failure to monitoring system

2. Document Generation Flow

Business Scenario: Generate PDF reports, invoices, or contracts automatically.

// FlexBase Handler for Document Generation
public class DocumentGenerationHandler : IDocumentGenerationHandler
{
    private readonly ILogger<DocumentGenerationHandler> _logger;
    private readonly DocumentGenerationRESTClient _restClient;
    
    public DocumentGenerationHandler(ILogger<DocumentGenerationHandler> logger, DocumentGenerationRESTClient restClient)
    {
        _logger = logger;
        _restClient = restClient;
    }
    
    public async Task Execute(GenerateDocumentCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        var documentRequest = new DocumentGenerationRequestDto
        {
            DocumentType = cmd.DocumentType,
            TemplateId = cmd.TemplateId,
            Data = cmd.DocumentData,
            OutputFormat = cmd.OutputFormat
        };

        var response = await _restClient.GenerateDocument(documentRequest);
        
        if (response.IsSuccessStatusCode)
        {
            var documentUrl = await response.Content.ReadAsStringAsync();
            _logger.LogInformation($"Document generated: {documentUrl}");
        }
        
        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Azure Logic Apps Flow:

HTTP Request Trigger - Receive document generation request
Get Template - Retrieve document template from Azure Storage
Populate Template - Fill template with provided data
Generate PDF - Convert to PDF using Azure Functions or third-party service
Store Document - Save to Azure Blob Storage
Return URL - Send document URL back to FlexBase

3. Data Synchronization Flow

Business Scenario: Sync data between different systems (CRM, ERP, external APIs).

// FlexBase Handler for Data Synchronization
public class DataSyncHandler : IDataSyncHandler
{
    private readonly ILogger<DataSyncHandler> _logger;
    private readonly DataSyncRESTClient _restClient;
    
    public DataSyncHandler(ILogger<DataSyncHandler> logger, DataSyncRESTClient restClient)
    {
        _logger = logger;
        _restClient = restClient;
    }
    
    public async Task Execute(SyncDataCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        var syncRequest = new DataSyncRequestDto
        {
            SourceSystem = cmd.SourceSystem,
            TargetSystem = cmd.TargetSystem,
            DataType = cmd.DataType,
            LastSyncDate = cmd.LastSyncDate
        };

        var response = await _restClient.SyncData(syncRequest);
        
        if (response.IsSuccessStatusCode)
        {
            var syncResult = await response.Content.ReadAsStringAsync();
            _logger.LogInformation($"Data sync completed: {syncResult}");
        }
        
        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Azure Logic Apps Flow:

Recurrence Trigger - Run every hour or daily
Get Data - Fetch data from source system (API, database)
Transform Data - Convert data format for target system
Validate Data - Check data integrity and business rules
Send to Target - Push data to target system
Log Results - Record sync statistics and errors

4. Payment Processing Flow

Business Scenario: Process payments through multiple payment gateways with fallback options.

// FlexBase Handler for Payment Processing
public class PaymentProcessingHandler : IPaymentProcessingHandler
{
    private readonly ILogger<PaymentProcessingHandler> _logger;
    private readonly PaymentProcessingRESTClient _restClient;
    
    public PaymentProcessingHandler(ILogger<PaymentProcessingHandler> logger, PaymentProcessingRESTClient restClient)
    {
        _logger = logger;
        _restClient = restClient;
    }
    
    public async Task Execute(ProcessPaymentCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        var paymentRequest = new PaymentProcessingRequestDto
        {
            Amount = cmd.Amount,
            Currency = cmd.Currency,
            PaymentMethod = cmd.PaymentMethod,
            CustomerId = cmd.CustomerId,
            OrderId = cmd.OrderId
        };

        var response = await _restClient.ProcessPayment(paymentRequest);
        
        if (response.IsSuccessStatusCode)
        {
            var paymentResult = await response.Content.ReadAsStringAsync();
            _logger.LogInformation($"Payment processed: {paymentResult}");
        }
        
        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Azure Logic Apps Flow:

HTTP Request Trigger - Receive payment request
Validate Payment - Check payment details and business rules
Try Primary Gateway - Attempt payment with primary provider
Condition - Check if primary payment succeeded
Try Secondary Gateway - Fallback to secondary provider if needed
Update Order Status - Update order status in database
Send Confirmation - Send payment confirmation email

5. File Processing Flow

Business Scenario: Process uploaded files (images, documents, CSV files) with validation and transformation.

// FlexBase Handler for File Processing
public class FileProcessingHandler : IFileProcessingHandler
{
    private readonly ILogger<FileProcessingHandler> _logger;
    private readonly FileProcessingRESTClient _restClient;
    
    public FileProcessingHandler(ILogger<FileProcessingHandler> logger, FileProcessingRESTClient restClient)
    {
        _logger = logger;
        _restClient = restClient;
    }
    
    public async Task Execute(ProcessFileCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        var fileRequest = new FileProcessingRequestDto
        {
            FileUrl = cmd.FileUrl,
            FileType = cmd.FileType,
            ProcessingOptions = cmd.ProcessingOptions,
            OutputFormat = cmd.OutputFormat
        };

        var response = await _restClient.ProcessFile(fileRequest);
        
        if (response.IsSuccessStatusCode)
        {
            var processingResult = await response.Content.ReadAsStringAsync();
            _logger.LogInformation($"File processed: {processingResult}");
        }
        
        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Azure Logic Apps Flow:

HTTP Request Trigger - Receive file processing request
Download File - Get file from Azure Blob Storage
Validate File - Check file format and size
Process File - Apply transformations (resize images, parse CSV, etc.)
Store Processed File - Save processed file to storage
Update Database - Record processing results
Send Notification - Notify user of completion

6. Approval Workflow Flow

Business Scenario: Implement approval workflows for expenses, leave requests, or document approvals.

// FlexBase Handler for Approval Workflow
public class ApprovalWorkflowHandler : IApprovalWorkflowHandler
{
    private readonly ILogger<ApprovalWorkflowHandler> _logger;
    private readonly ApprovalWorkflowRESTClient _restClient;
    
    public ApprovalWorkflowHandler(ILogger<ApprovalWorkflowHandler> logger, ApprovalWorkflowRESTClient restClient)
    {
        _logger = logger;
        _restClient = restClient;
    }
    
    public async Task Execute(SubmitApprovalCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        var approvalRequest = new ApprovalWorkflowRequestDto
        {
            RequestId = cmd.RequestId,
            RequestType = cmd.RequestType,
            RequesterId = cmd.RequesterId,
            ApproverId = cmd.ApproverId,
            RequestData = cmd.RequestData
        };

        var response = await _restClient.SubmitApproval(approvalRequest);
        
        if (response.IsSuccessStatusCode)
        {
            var approvalResult = await response.Content.ReadAsStringAsync();
            _logger.LogInformation($"Approval submitted: {approvalResult}");
        }
        
        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Azure Logic Apps Flow:

HTTP Request Trigger - Receive approval request
Validate Request - Check request data and business rules
Send Approval Email - Send approval request to approver
Wait for Response - Wait for approver decision (with timeout)
Process Decision - Handle approval or rejection
Update Status - Update request status in database
Notify Requester - Send notification to original requester

7. Integration with External APIs Flow

Business Scenario: Integrate with third-party services like weather APIs, shipping providers, or social media platforms.

// FlexBase Handler for External API Integration
public class ExternalApiHandler : IExternalApiHandler
{
    private readonly ILogger<ExternalApiHandler> _logger;
    private readonly ExternalApiRESTClient _restClient;
    
    public ExternalApiHandler(ILogger<ExternalApiHandler> logger, ExternalApiRESTClient restClient)
    {
        _logger = logger;
        _restClient = restClient;
    }
    
    public async Task Execute(CallExternalApiCommand cmd, IFlexServiceBusContext serviceBusContext)
    {
        var apiRequest = new ExternalApiRequestDto
        {
            ApiEndpoint = cmd.ApiEndpoint,
            RequestData = cmd.RequestData,
            Authentication = cmd.Authentication,
            RetryCount = cmd.RetryCount
        };

        var response = await _restClient.CallExternalApi(apiRequest);
        
        if (response.IsSuccessStatusCode)
        {
            var apiResult = await response.Content.ReadAsStringAsync();
            _logger.LogInformation($"External API call successful: {apiResult}");
        }
        
        // Fire domain events if needed
        await this.Fire(EventCondition, serviceBusContext);
    }
}

Azure Logic Apps Flow:

HTTP Request Trigger - Receive API call request
Prepare Request - Format request for external API
Authenticate - Handle API authentication (OAuth, API keys, etc.)
Call External API - Make HTTP request to external service
Handle Response - Process API response
Transform Data - Convert response to internal format
Return Result - Send processed data back to FlexBase

🎯 Flow Pattern Benefits

1. Reliability

Retry Logic - Automatic retry on failures
Error Handling - Comprehensive error management
Monitoring - Built-in logging and monitoring
Fallback Options - Alternative paths when primary fails

2. Scalability

Parallel Processing - Handle multiple requests simultaneously
Load Balancing - Distribute workload across instances
Auto-scaling - Scale based on demand
Resource Management - Efficient resource utilization

3. Maintainability

Visual Design - Easy to understand and modify
Reusable Components - Common patterns across workflows
Version Control - Track changes and rollback if needed
Testing - Built-in testing capabilities

4. Integration

Multiple Connectors - Connect to hundreds of services
Custom Connectors - Build custom integrations
API Management - Secure and manage API calls
Data Transformation - Easy data format conversion

This document demonstrates how FlexBase provides a clean, maintainable, and scalable approach to integrating with Azure Logic Apps, enabling enterprise applications to leverage powerful workflow automation capabilities.

PreviousHow Much Abstraction NextAI In Flexbase

Last updated 7 months ago