Prozesse auflisten

Der ProcessDefinitionsClient ermöglicht es, alle in der Engine verfügbaren Prozessmodelle aufzulisten.

GetProcessModelsAsync()

Ruft alle deployten Prozessmodelle ab:


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
// Alle Prozesse abrufen
var processes = await client.GetProcessModelsAsync();
 
foreach (var process in processes)
{
    Console.WriteLine($"Prozess: {process.Id}");
    Console.WriteLine($"  Name: {process.Name}");
    Console.WriteLine($"  Version: {process.Version}");
    Console.WriteLine($"  Start-Events: {process.StartEvents.Count}");
    Console.WriteLine();
}

ProcessModel Properties

Ein ProcessModel enthält folgende wichtige Properties:

Property	Typ	Beschreibung
`Id`	`string`	Eindeutige ID des Prozessmodells
`Name`	`string`	Name des Prozesses aus dem BPMN
`Version`	`string`	Version des Prozessmodells
`StartEvents`	`List<StartEvent>`	Verfügbare Start-Events
`EndEvents`	`List<EndEvent>`	Definierte End-Events
`Xml`	`string`	BPMN-XML des Prozesses

Start-Events anzeigen


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
var processes = await client.GetProcessModelsAsync();
 
foreach (var process in processes)
{
    Console.WriteLine($"Prozess: {process.Name} (ID: {process.Id})");
 
    if (process.StartEvents.Any())
    {
        Console.WriteLine("  Start-Events:");
        foreach (var startEvent in process.StartEvents)
        {
            Console.WriteLine($"    - {startEvent.Id} ({startEvent.Name})");
            Console.WriteLine($"      Type: {startEvent.EventType}");
        }
    }
    else
    {
        Console.WriteLine("  Keine Start-Events definiert");
    }
 
    Console.WriteLine();
}

Spezifischen Prozess finden

Nach ProcessModelId


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
var processModelId = "OrderProcess";
 
var processes = await client.GetProcessModelsAsync();
var orderProcess = processes.FirstOrDefault(p => p.Id == processModelId);
 
if (orderProcess != null)
{
    Console.WriteLine($"Gefunden: {orderProcess.Name}");
    Console.WriteLine($"Version: {orderProcess.Version}");
    Console.WriteLine($"Start-Events: {orderProcess.StartEvents.Count}");
}
else
{
    Console.WriteLine($"Prozess '{processModelId}' nicht gefunden");
}

Nach Name suchen


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
var searchName = "Order";
 
var processes = await client.GetProcessModelsAsync();
var matchingProcesses = processes
    .Where(p => p.Name.Contains(searchName, StringComparison.OrdinalIgnoreCase))
    .ToList();
 
Console.WriteLine($"Gefundene Prozesse mit '{searchName}': {matchingProcesses.Count}");
 
foreach (var process in matchingProcesses)
{
    Console.WriteLine($"  - {process.Name} (ID: {process.Id})");
}

BPMN-XML abrufen


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
var processModelId = "OrderProcess";
 
var processes = await client.GetProcessModelsAsync();
var process = processes.FirstOrDefault(p => p.Id == processModelId);
 
if (process != null)
{
    // BPMN-XML ist in der Xml-Property verfügbar
    var bpmnXml = process.Xml;
 
    // XML in Datei speichern
    await File.WriteAllTextAsync($"{process.Id}.bpmn", bpmnXml);
 
    Console.WriteLine($"BPMN gespeichert: {process.Id}.bpmn");
}

Die Xml-Property enthält das vollständige BPMN 2.0 XML des Prozesses und kann für Backup, Export oder Analyse verwendet werden.

Prozess-Übersicht mit Statistiken


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var definitionsClient = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
var instancesClient = ClientFactory.CreateProcessInstancesClient(engineAddress);
 
// Alle Prozesse abrufen
var processes = await definitionsClient.GetProcessModelsAsync();
 
Console.WriteLine($"Gesamt deployete Prozesse: {processes.Count}");
Console.WriteLine();
 
foreach (var process in processes)
{
    Console.WriteLine($"Prozess: {process.Name}");
    Console.WriteLine($"  ID: {process.Id}");
    Console.WriteLine($"  Version: {process.Version}");
 
    // Instanzen für diesen Prozess zählen
    var instances = await instancesClient.QueryAsync(query => {
        query.FilterByProcessModelId(process.Id);
    });
 
    Console.WriteLine($"  Instanzen gesamt: {instances.Count}");
 
    // Nach Status gruppieren
    var runningCount = instances.Count(i => i.State == ProcessState.Running);
    var finishedCount = instances.Count(i => i.State == ProcessState.Finished);
    var errorCount = instances.Count(i => i.State == ProcessState.Error);
 
    Console.WriteLine($"    - Laufend: {runningCount}");
    Console.WriteLine($"    - Beendet: {finishedCount}");
    Console.WriteLine($"    - Fehler: {errorCount}");
    Console.WriteLine();
}

Mit Authentifizierung

Wenn die Engine mit Authority gesichert ist:


using ProcessCube.Engine;
using ProcessCube.Engine.Client.Identity;
 
// Identity Provider erstellen
var identityProvider = new ClientCredentialsIdentityProvider(
    authorityAddress: "http://localhost:11235",
    clientId: "my-service",
    clientSecret: "secret-key",
    scope: "engine_read"
);
 
// Token abrufen
var identity = await identityProvider.GetIdentityAsync();
 
// Client mit Identity erstellen
var client = ClientFactory.CreateProcessDefinitionsClient(
    engineAddress: "http://localhost:8000",
    identity: identity
);
 
// Prozesse abrufen (authentifiziert)
var processes = await client.GetProcessModelsAsync();
 
Console.WriteLine($"Anzahl Prozesse: {processes.Count}");

Filtern und Sortieren


using ProcessCube.Engine;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
var processes = await client.GetProcessModelsAsync();
 
// Nach Name sortieren
var sortedByName = processes
    .OrderBy(p => p.Name)
    .ToList();
 
Console.WriteLine("Prozesse alphabetisch sortiert:");
foreach (var process in sortedByName)
{
    Console.WriteLine($"  - {process.Name}");
}
 
// Nur Prozesse mit bestimmter Version
var version2Processes = processes
    .Where(p => p.Version.StartsWith("2."))
    .ToList();
 
Console.WriteLine($"\nProzesse mit Version 2.x: {version2Processes.Count}");
 
// Prozesse mit mindestens 2 Start-Events
var multiStartProcesses = processes
    .Where(p => p.StartEvents.Count >= 2)
    .ToList();
 
Console.WriteLine($"Prozesse mit mehreren Start-Events: {multiStartProcesses.Count}");

Fehlerbehandlung


using ProcessCube.Engine;
using ProcessCube.Engine.Client.Exceptions;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
try
{
    var processes = await client.GetProcessModelsAsync();
    Console.WriteLine($"Erfolgreich {processes.Count} Prozesse abgerufen");
}
catch (EngineClientException ex) when (ex.StatusCode == 401)
{
    Console.WriteLine("Nicht authentifiziert - Login erforderlich");
}
catch (EngineClientException ex) when (ex.StatusCode == 403)
{
    Console.WriteLine("Zugriff verweigert - Fehlende Berechtigung");
}
catch (HttpRequestException ex)
{
    Console.WriteLine($"Verbindungsfehler: {ex.Message}");
    Console.WriteLine("Prüfen Sie, ob die Engine erreichbar ist");
}
catch (Exception ex)
{
    Console.WriteLine($"Unerwarteter Fehler: {ex.Message}");
}

Best Practice: Cachen Sie die Prozessliste, wenn sich die deployten Prozesse selten ändern. Dies reduziert die Anzahl der API-Aufrufe.

Export aller Prozesse


using ProcessCube.Engine;
using System.IO;
 
var engineAddress = "http://localhost:8000";
var client = ClientFactory.CreateProcessDefinitionsClient(engineAddress);
 
var processes = await client.GetProcessModelsAsync();
 
// Export-Verzeichnis erstellen
var exportDir = "ProcessExport";
Directory.CreateDirectory(exportDir);
 
foreach (var process in processes)
{
    // Dateinamen erstellen (ID_Version.bpmn)
    var fileName = $"{process.Id}_{process.Version}.bpmn";
    var filePath = Path.Combine(exportDir, fileName);
 
    // BPMN-XML speichern
    await File.WriteAllTextAsync(filePath, process.Xml);
 
    Console.WriteLine($"Exportiert: {fileName}");
}
 
Console.WriteLine($"\n{processes.Count} Prozesse nach '{exportDir}' exportiert");

Nächste Schritte

Prozess deployen - BPMN-Diagramme hochladen
Prozess starten - Instanzen erstellen
Prozess-Verwaltung - Zurück zur Übersicht