Skip to Content
DocsLowcodeConceptsProcessCube®-spezifische Konzepte

ProcessCube®-spezifische Konzepte

ProcessCube® LowCode erweitert Node-RED um spezifische Konzepte für die Prozessautomatisierung. Diese Seite erklärt die wichtigsten ProcessCube®-spezifischen Patterns und Architekturprinzipien.

Engine-Integration

Die ProcessCube® Engine ist das Herzstück der Plattform. Sie führt BPMN-Workflows aus und verwaltet Prozess-Instanzen und UserTasks.

Engine-API

LowCode kommuniziert mit der Engine via REST-API:

Base URL:

http://engine:8000/api

Wichtige Endpunkte:

GET    /process-models           # Alle Process Models abrufen
POST   /process-models/{id}/start  # Prozess starten
GET    /user-tasks                # UserTasks abrufen
POST   /user-tasks/{id}/finish    # UserTask beenden
GET    /process-instances         # Prozess-Instanzen abrufen

Engine-Nodes (Enterprise Image)

ProcessCube® LowCode bietet spezielle Nodes für die Engine-Integration:

Start Process Node

Funktion: Startet einen BPMN-Prozess

Input:

msg.processModelId = "MyProcess_v1";
msg.payload = {
  // Input Values
  customerName: "Max Mustermann",
  amount: 1000
};

Output:

msg.processInstanceId = "abc-123-def-456";
msg.processInstance = {
  id: "abc-123-def-456",
  processModelId: "MyProcess_v1",
  state: "running",
  startedAt: "2025-01-15T10:00:00Z"
};

Finish UserTask Node

Funktion: Beendet einen UserTask und setzt Prozess fort

Input:

msg.userTaskInstanceId = "ut-123";
msg.payload = {
  // UserTask Result
  approved: true,
  comment: "Alles in Ordnung"
};

Output:

msg.success = true;
msg.userTask = {
  id: "ut-123",
  state: "finished",
  finishedAt: "2025-01-15T10:05:00Z"
};

Query Process Instances Node

Funktion: Fragt laufende Prozess-Instanzen ab

Input:

msg.processModelId = "MyProcess_v1";  // Optional
msg.state = "running";                // Optional: running, finished, error

Output:

msg.payload = [
  {
    id: "pi-1",
    processModelId: "MyProcess_v1",
    state: "running",
    startedAt: "2025-01-15T10:00:00Z"
  },
  // ...
];

Engine Event Node

Funktion: Abonniert Engine-Events

Configuration:

Event Type: "userTaskCreated"  // oder: processStarted, processFinished, etc.
Engine URL: ${ENGINE_URL}

Output bei Event:

msg.payload = {
  eventType: "userTaskCreated",
  userTask: {
    id: "ut-456",
    processInstanceId: "pi-789",
    name: "Approve Request",
    formFields: {...}
  }
};

Event-Driven Architecture

ProcessCube® LowCode nutzt eine event-basierte Architektur für lose Kopplung und hohe Skalierbarkeit.

Engine-Events

Die Engine publiziert Events, auf die LowCode reagieren kann:

Event-Typen:

  • processStarted: Prozess wurde gestartet
  • processFinished: Prozess wurde beendet
  • userTaskCreated: UserTask wurde erstellt
  • userTaskFinished: UserTask wurde beendet
  • processError: Fehler im Prozess aufgetreten

Event-Handler Pattern

Pattern: Subscribe-Process-Respond

[Engine Event: userTaskCreated]
  → [Function: Extract Data]
  → [HTTP Request: Send Notification]
  → [Debug: Log Success]

Beispiel-Code:

// Function Node: Extract Data
const userTask = msg.payload.userTask;
 
msg.notification = {
  to: "user@example.com",
  subject: `Neue Aufgabe: ${userTask.name}`,
  body: `Sie haben eine neue Aufgabe in Prozess ${userTask.processInstanceId}`
};
 
return msg;

Event-Flow Patterns

Pattern 1: Notification on UserTask

[Engine Event: userTaskCreated]
  → [Function: Build Email]
  → [SMTP: Send Email]
  → [Debug: Confirm]

Pattern 2: Auto-Complete Simple Tasks

[Engine Event: userTaskCreated]
  → [Function: Check if auto-completable]
  → [Switch: Based on task type]
      ├─ Auto: [Finish UserTask Node]
      └─ Manual: [Send Notification]

Pattern 3: Process Monitoring

[Engine Event: processStarted/Finished]
  → [Function: Update Statistics]
  → [Context: Store Metrics]
  → [Dashboard: Update Chart]

Context Storage Patterns

Context ermöglicht das Speichern von Zustandsinformationen über Messages hinweg.

Flow Context (Empfohlen)

Daten innerhalb eines Flows teilen:

// Flow 1: HTTP-Login Endpoint
[http in: POST /login]
  → [function: validate credentials]
  → [function: generate token]
  → [function: store in context]  // flow.set("userToken", token)
  → [http response: return token]
 
// Flow 2: HTTP-API Endpoint (gleicher Flow-Tab)
[http in: GET /api/data]
  → [function: load token]  // token = flow.get("userToken")
  → [function: validate token]
  → [database: query data]
  → [http response]

Global Context (Mit Vorsicht)

Daten zwischen verschiedenen Flows teilen:

// Flow A: Configuration Flow
global.set("engineUrl", "http://engine:8000");
global.set("authorityUrl", "http://authority:5000");
 
// Flow B: API Flow
const engineUrl = global.get("engineUrl");
msg.url = `${engineUrl}/api/process-models`;

Hinweis: Global Context kann zu schwer debuggbaren Abhängigkeiten führen. Verwenden Sie es sparsam!

Persistent Context

Context kann persistent gespeichert werden (File oder Redis):

// Speichern mit Persistence
flow.set("cache", data, "file");  // In Datei speichern
 
// Laden aus Persistence
const cache = flow.get("cache", "file");  // Aus Datei laden

Konfiguration in settings.js:

contextStorage: {
  default: "memoryOnly",
  file: {
    module: "localfilesystem"
  },
  redis: {
    module: "redis",
    config: {
      host: "redis",
      port: 6379
    }
  }
}

Authentication & Authorization

ProcessCube® nutzt OAuth 2.0 mit der ProcessCube® Authority.

Token-basierte Authentication

Pattern: Token Acquisition Flow

[Inject: Trigger every 50 minutes]
  → [Function: Prepare Token Request]
  → [HTTP Request: POST /connect/token]
  → [Function: Parse Token Response]
  → [Context: Store Token]  // flow.set("authToken", token)

Function: Prepare Token Request:

msg.url = `${env.get("AUTHORITY_URL")}/connect/token`;
msg.method = "POST";
msg.headers = {
  "Content-Type": "application/x-www-form-urlencoded"
};
msg.payload = {
  grant_type: "client_credentials",
  client_id: env.get("CLIENT_ID"),
  client_secret: env.get("CLIENT_SECRET"),
  scope: "engine:read engine:write"
};
return msg;

Function: Parse Token Response:

const token = msg.payload.access_token;
flow.set("authToken", token);
msg.payload = {success: true, expires_in: msg.payload.expires_in};
return msg;

Authenticated API Calls

Pattern: Use Stored Token

[HTTP In: GET /api/processes]
  → [Function: Load Token]
  → [HTTP Request: Engine API]
  → [HTTP Response]

Function: Load Token:

const token = flow.get("authToken");
if (!token) {
  msg.statusCode = 401;
  msg.payload = {error: "Not authenticated"};
  return msg;
}
 
msg.headers = {
  "Authorization": `Bearer ${token}`,
  "Content-Type": "application/json"
};
msg.url = `${env.get("ENGINE_URL")}/api/process-models`;
return msg;

Error Handling Patterns

Robuste Error Handling-Strategien sind essentiell.

Pattern 1: Catch-All Error Handler

[Catch Node: Scope = All Flows]
  → [Function: Log Error]
  → [HTTP Request: Send to Monitoring]
  → [Debug: Error Details]

Function: Log Error:

const error = msg.error;
const errorDetails = {
  timestamp: new Date().toISOString(),
  source: error.source.name,
  message: error.message,
  stack: error.stack
};
 
flow.set("lastError", errorDetails);
msg.payload = errorDetails;
return msg;

Pattern 2: Retry with Exponential Backoff

[HTTP Request]
  ├─ Success → [Output]
  └─ Error → [Function: Check Retry Count]
              ├─ Retry < 3 → [Delay] → [HTTP Request]
              └─ Retry >= 3 → [Error Handler]

Function: Check Retry Count:

let retryCount = context.get("retryCount") || 0;
 
if (retryCount < 3) {
  context.set("retryCount", retryCount + 1);
  msg.delay = Math.pow(2, retryCount) * 1000;  // 1s, 2s, 4s
  return [null, msg];  // Output 2: Retry
} else {
  context.set("retryCount", 0);
  return [msg, null];  // Output 1: Give up
}

Pattern 3: Circuit Breaker

[HTTP Request]
  ├─ Success → [Function: Reset Circuit] → [Output]
  └─ Error → [Function: Increment Failure Count]
              ├─ < Threshold → [Output: Error]
              └─ >= Threshold → [Context: Open Circuit] → [Fallback Response]

Message Passing Patterns

Effiziente Message-Verarbeitung zwischen Nodes.

Pattern 1: Message Enrichment

Daten schrittweise anreichern:

[HTTP In]
  → [Function: Validate]
  → [Database: Load User]
  → [Function: Enrich with User Data]
  → [HTTP Request: Call API]
  → [Function: Enrich with API Data]
  → [HTTP Response]

Pattern 2: Message Splitting

Eine Message in mehrere aufteilen:

[HTTP In: Array of Items]
  → [Split Node]
  → [Function: Process Single Item]
  → [Join Node]
  → [HTTP Response]

Pattern 3: Message Aggregation

Mehrere Messages zusammenführen:

[Event A] ─┐
[Event B] ─┼→ [Join Node] → [Function: Combine] → [Output]
[Event C] ─┘

Best Practices

1. Verwenden Sie Environment Variables

// ❌ Schlecht
const url = "http://localhost:8000";
 
// ✅ Gut
const url = env.get("ENGINE_URL");

2. Token Refresh implementieren

Tokens laufen ab! Implementieren Sie automatisches Refresh:

[Inject: Every 50 minutes]
  → [Get New Token]
  → [Store in Context]

3. Error Handling nicht vergessen

Jeder Flow sollte Error Handling haben:

[Function] ──error──> [Catch] → [Log] → [Alert]

4. Context sparsam nutzen

Context kann Memory-Leaks verursachen. Löschen Sie nicht mehr benötigte Daten:

flow.set("tempData", null);  // Daten löschen

5. Engine-Events abonnieren

Nutzen Sie Engine-Events für reaktive Flows statt Polling:

// ❌ Schlecht: Polling
[Inject: Every 10s] → [Query UserTasks]

// ✅ Gut: Event-basiert
[Engine Event: userTaskCreated] → [Process UserTask]

Nächste Schritte

Ressourcen

Portal + UserTask IntegrationKonfiguration