Hosting Integration

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using ProcessCube.Engine;
 
var builder = Host.CreateDefaultBuilder(args);
 
builder.ConfigureServices(services =>
{
    services.Configure<ApiClientSettings>(settings =>
    {
        settings.ProcessCubeEngineUrl = new Uri("http://localhost:8000");
    });
 
    // Worker-Handler registrieren
    services.AddScoped<ProcessOrderHandler>();
});
 
// External Task Worker hinzufügen
builder.UseExternalTaskWorkers();
 
var host = builder.Build();
 
await host.RunAsync();

using ProcessCube.Engine.ExternalTaskWorkers;
 
[ExternalTaskTopic("ProcessOrder")]
public class ProcessOrderHandler
{
    private readonly ILogger<ProcessOrderHandler> _logger;
 
    public ProcessOrderHandler(ILogger<ProcessOrderHandler> logger)
    {
        _logger = logger;
    }
 
    public async Task<OrderResult> HandleAsync(ExternalTask externalTask)
    {
        var input = externalTask.Tokens[TokenType.OnEnter].GetPayload<OrderInput>();
 
        _logger.LogInformation("Processing order: {OrderId}", input.OrderId);
 
        // Geschäftslogik
        await ProcessOrderAsync(input);
 
        return new OrderResult(input.OrderId, "Completed");
    }
 
    private async Task ProcessOrderAsync(OrderInput input)
    {
        // Verarbeitung hier
        await Task.Delay(1000);
    }
}
 
internal sealed record OrderInput(string OrderId, decimal Amount);
internal sealed record OrderResult(string OrderId, string Status);

{
  "ProcessCube": {
    "EngineUrl": "http://localhost:8000",
    "AuthorityUrl": "http://localhost:11235",
    "ClientId": "worker-service",
    "ClientSecret": "secret-key"
  }
}

[ExternalTaskTopic("SendEmail")]
public class SendEmailHandler
{
    private readonly IEmailService _emailService;
    private readonly ILogger<SendEmailHandler> _logger;
 
    public SendEmailHandler(
        IEmailService emailService,
        ILogger<SendEmailHandler> logger)
    {
        _emailService = emailService;
        _logger = logger;
    }
 
    public async Task<EmailResult> HandleAsync(ExternalTask externalTask)
    {
        var input = externalTask.Tokens[TokenType.OnEnter].GetPayload<EmailInput>();
 
        _logger.LogInformation("Sending email to {Recipient}", input.Recipient);
 
        await _emailService.SendAsync(input.Recipient, input.Subject, input.Body);
 
        return new EmailResult("Sent");
    }
}