Getting Started

dotnet add package ProcessCube.Engine.Client

Install-Package ProcessCube.Engine.Client

<PackageReference Include="ProcessCube.Engine.Client" Version="*" />

using ProcessCube.Engine;
 
// Engine-Adresse
var engineAddress = "http://localhost:8000";
 
// Verschiedene spezialisierte Clients erstellen
var appInfoClient = ClientFactory.CreateApplicationInfoClient(engineAddress);
var processClient = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
var userTaskClient = ClientFactory.CreateUserTaskClient(engineAddress);

using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateApplicationInfoClient(engineAddress);
 
// Engine-Informationen abrufen
var info = await client.GetApplicationInfoAsync();
 
Console.WriteLine($"Process Engine: {info.Name} @ {info.Version}");

var client = ClientFactory.CreateApplicationInfoClient(engineAddress);
 
var info = await client.GetApplicationInfoAsync();
var authorityAddress = await client.GetAuthorityAddressAsync();

var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
// Prozesse auflisten
var processes = await client.GetProcessModelsAsync();
 
// Prozess starten
var response = await client.StartProcessInstanceAsync(
    processModelId: "OrderProcess",
    startEventId: "StartEvent1",
    initialToken: new { orderId = "12345" }
);

var client = ClientFactory.CreateUserTaskClient(engineAddress);
 
// User Tasks abfragen
var userTasks = await client.QueryAsync(query => {
    query.FilterByState(UserTaskState.Suspended);
});
 
// User Task abschließen
await client.FinishUserTaskAsync(userTask, result);

var client = ClientFactory.CreateExternalTaskClient(engineAddress);
 
// External Tasks abrufen
var tasks = await client.FetchAndLockAsync(
    topic: "ProcessPayment",
    maxTasks: 10,
    lockDuration: TimeSpan.FromSeconds(60)
);

using ProcessCube.Engine;
using ProcessCube.Engine.Client.Identity;
 
// OAuth 2.0 Credentials
var authorityAddress = "http://localhost:11235";
var clientId = "my-service";
var clientSecret = "secret-key";
 
// Identity Provider erstellen
var identityProvider = new ClientCredentialsIdentityProvider(
    authorityAddress: authorityAddress,
    clientId: clientId,
    clientSecret: clientSecret,
    scope: "engine_read engine_write"
);
 
// Authentifizierung durchführen
var identity = await identityProvider.GetIdentityAsync();
 
// Client mit Identity erstellen
var client = ClientFactory.CreateProcessDefinitionsClient(
    engineAddress: "http://localhost:8000",
    identity: identity
);
 
// Jetzt authentifizierte Requests ausführen
var processes = await client.GetProcessModelsAsync();

using ProcessCube.Engine.Client.Identity;
 
var identityProvider = new ClientCredentialsIdentityProvider(
    authorityAddress: "http://localhost:11235",
    clientId: "my-service",
    clientSecret: "secret-key",
    scope: "engine_read engine_write"
);
 
// Periodische Provisionierung starten
var identityHolder = await identityProvider.StartPeriodicProvisioningAsync();
 
// Client mit IdentityHolder erstellen
var client = ClientFactory.CreateProcessDefinitionsClient(
    engineAddress: "http://localhost:8000",
    identityHolder: identityHolder
);
 
// Token wird automatisch vor Ablauf erneuert
var processes = await client.GetProcessModelsAsync();
 
// Provisionierung stoppen wenn nicht mehr benötigt
await identityHolder.StopPeriodicProvisioningAsync();

// ✅ Empfohlen - Async/Await verwenden
var processes = await client.GetProcessModelsAsync();
 
// ❌ Nicht empfohlen - Blockierender Call
var processes = client.GetProcessModelsAsync().Result;

// Startup.cs oder Program.cs
public void ConfigureServices(IServiceCollection services)
{
    // Engine-Adresse konfigurieren
    var engineAddress = Configuration["ProcessCube:EngineAddress"];
 
    // Clients registrieren
    services.AddSingleton(sp =>
        ClientFactory.CreateProcessDefinitionsClient(engineAddress)
    );
 
    services.AddSingleton(sp =>
        ClientFactory.CreateUserTaskClient(engineAddress)
    );
}
 
// Controller oder Service
public class OrderController : ControllerBase
{
    private readonly IProcessDefinitionsClient _processClient;
 
    public OrderController(IProcessDefinitionsClient processClient)
    {
        _processClient = processClient;
    }
 
    [HttpPost("orders")]
    public async Task<IActionResult> CreateOrder(OrderDto order)
    {
        var response = await _processClient.StartProcessInstanceAsync(
            processModelId: "OrderProcess",
            startEventId: "StartEvent1",
            initialToken: order
        );
 
        return Ok(new { processInstanceId = response.ProcessInstanceId });
    }
}

// Payload als Record definieren
internal sealed record OrderPayload(
    string OrderId,
    string CustomerName,
    decimal Amount
);
 
// Prozess mit typisiertem Payload starten
var payload = new OrderPayload(
    OrderId: "ORD-12345",
    CustomerName: "Max Mustermann",
    Amount: 1500.00m
);
 
var response = await client.StartProcessInstanceAsync(
    processModelId: "OrderProcess",
    startEventId: "StartEvent1",
    initialToken: payload
);

using ProcessCube.Engine.Client.Exceptions;
 
try
{
    var response = await client.StartProcessInstanceAsync(
        processModelId: "OrderProcess",
        startEventId: "StartEvent1",
        initialToken: payload
    );
 
    Console.WriteLine($"Prozess gestartet: {response.ProcessInstanceId}");
}
catch (EngineClientException ex)
{
    // Engine-spezifische Fehler
    Console.WriteLine($"Engine-Fehler: {ex.Message}");
}
catch (HttpRequestException ex)
{
    // Netzwerk-Fehler
    Console.WriteLine($"Verbindungsfehler: {ex.Message}");
}
catch (Exception ex)
{
    // Allgemeine Fehler
    Console.WriteLine($"Fehler: {ex.Message}");
}

using Microsoft.Extensions.Logging;
 
var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddConsole()
        .SetMinimumLevel(LogLevel.Debug);
});
 
// Logger an ClientFactory übergeben
ClientFactory.ConfigureLogging(loggerFactory);
 
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);