Input und Output einer Aktivität

Übersicht

Jede Aktivität in einem Prozess (z. B. User Task, Service Task, Script Task) kann Daten empfangen (Input) und Daten zurückgeben (Output). Die Definition von Input und Output steuert, welche Daten eine Aktivität verarbeitet und welche Ergebnisse sie an den Prozess zurückgibt.

Kurz zusammengefasst

Über Input-Parameter wird festgelegt, welche Daten eine Aktivität erhält. Über Output-Parameter wird definiert, welche Ergebnisse zurück in den Prozess fließen. Zur Transformation der Daten zwischen Aktivitäten wird JSONata verwendet – eine elegante Abfragesprache für JSON-Daten.

Warum das hilfreich ist

Durch die gezielte Steuerung von Input und Output bleiben Prozesse übersichtlich, Aktivitäten erhalten nur die benötigten Daten und Ergebnisse werden sauber strukturiert zurückgegeben.

Grundkonzept

Input-Parameter

Der Input-Parameter definiert, welche Daten eine Aktivität erhält. Dies können sein:

Einzelne Felder aus den Prozessdaten
Ganze Objekte oder Arrays
Transformierte Daten mittels JSONata
Berechnete Werte

Beispiel: Eine Aktivität benötigt nur die Rechnungsnummer und den Empfänger:

{
  "invoice_number": $.invoice.number,
  "recipient": $.invoice.recipient.name
}

Output-Parameter

Der Output-Parameter transformiert das Rohergebnis der Aktivität in ein strukturiertes Format. Er bestimmt, welche Daten aus dem Ergebnis extrahiert und wie sie aufbereitet werden.

Zusammenspiel mit Ergebnispfad

Der Output-Parameter transformiert die Daten (WAS), der Ergebnispfad bestimmt, wo sie gespeichert werden (WO).

Beispiel: Das Ergebnis einer Berechnung wird strukturiert:

{ "calculated_value": $.result, "timestamp": $.date }

JSONata – Transformation von Daten

JSONata ist eine leistungsstarke Abfragesprache zum Transformieren, Filtern und Umformen von JSON-Daten. Sie ermöglicht es, Daten zwischen Aktivitäten flexibel anzupassen.

Grundlegende Syntax

Syntax	Beschreibung	Beispiel
`$.property`	Zugriff auf ein Feld	`$.customer.name`
`items[$.price>100]`	Array filtern	Nur Items mit Preis > 100
`{ "key": $.value }`	Neues Objekt erstellen	Objekt mit transformierten Werten
`$sum(array)`	Array summieren	Summe aller Werte
`$now()`	Aktueller Zeitstempel	Heutiges Datum/Uhrzeit

Wichtige Funktionen

$sum(array) – Summiert numerische Werte
$filter(array, function) – Filtert Array nach Bedingung
$map(array, function) – Transformiert jedes Element
$now() – Aktueller Zeitstempel
$substring(text, start, length) – Teilstring extrahieren
$split(text, separator) – Text aufteilen

JSONata ausprobieren

Pantarey JSONata-Editor: Im Prozess Designer können Expressions direkt testen und live das Ergebnis ansehen.
Alternativ die offizielle JSONata Playground: try.jsonata.org

Anwendung in Pantarey

Im Prozess Designer

Prozess Designer öffnen
Eine Aktivität auswählen (z. B. Service Task)
In den Properties die Felder „Input Parameter" und „Output Parameter" finden
JSONata-Expression eingeben
Prozess speichern und deployen

Typische Szenarien

Szenario	Input Parameter	Output Parameter
Ganze Datenstruktur übergeben	`$`	`result`
Nur bestimmte Felder	`{ "id": $.order_id }`	`order_status`
Berechnetes Ergebnis	`{ "total": $sum($.items.price) }`	`calculated_total`
Transformation	`$.items[price > 100]`	`filtered_items`

Best Practices

Input-Parameter

✅ Übergebe nur die tatsächlich benötigten Daten
✅ Sprechende Feldnamen
✅ Transformiere Daten direkt im Input, statt in der Aktivität
❌ Vermeide es, die gesamte Prozessvariable ($) zu übergeben, wenn nur einzelne Felder benötigt werden

Output-Parameter

✅ Definiere einen klaren Output-Pfad (z. B. result.customer_data)
✅ Strukturiere Ergebnisse sinnvoll
✅ Vermeide Überschreiben wichtiger Prozessdaten
❌ Generische Namen wie data oder output

JSONata-Expressions

✅ Teste Expressions im Pantarey JSONata-Editor (im Prozess Designer verfügbar)
✅ Alternativ: try.jsonata.org
✅ Expressions sollten übersichtlich und lesbar
✅ Kommentiere komplexe Logik
❌ Vermeide verschachtelte Expressions, die schwer zu debuggen sind

Praxisbeispiele

Einzelnes Attribut ändern

Extrahiere das order-Objekt und wird der Status gesetzt auf abgeschlossen.

Input:

{ "order": { "id": "ORD-1001", "status": "offen", "total": 249.99 } }

JSONata Expression:

$.order ~> | $ | { "status": "abgeschlossen" } |

Output:

{ "id": "ORD-1001", "status": "abgeschlossen", "total": 249.99 }

Alter in Jahren berechnen

Berechne das Alter in Jahren aus dem Geburtsdatum.

Input:

{ "birthday": "1991-03-06" }

JSONata Expression:

( $now := $toMillis($now()); $birthMillis := $toMillis(birthday & "T12:00:00Z"); $years := $floor(($now - $birthMillis) / (365.25 * 24 * 60 * 60 * 1000)); $years )

Output:

34

Ersten und letzten Tag des Vormonats ermitteln

Berechne das Start- und Enddatum des vorherigen Monats als ISO-Datum.

JSONata Expression:

( $firstThisMonthMs := $toMillis($substring($now(), 0, 7) & "-01T00:00:00Z"); $lastPrevISO := $fromMillis($firstThisMonthMs - 1); { "firstDayPrevMonth": $substring($lastPrevISO, 0, 7) & "-01", "lastDayPrevMonth": $substring($lastPrevISO, 0, 10) } )

Output:

{ "firstDayPrevMonth": "2025-12-01", "lastDayPrevMonth": "2025-12-31" }

Attribut zu jedem Array-Objekt hinzufügen

Erweitert jedes Element eines Arrays um ein zusätzliches Feld additionalAttr.

Input:

{ "array": [ {"existingAttr": "1"}, {"existingAttr": "2"} ] }

JSONata Expression:

$.array.$merge([$, {"additionalAttr": "Hello"}])

Output:

[ { "existingAttr": "1", "additionalAttr": "Hello" }, { "existingAttr": "2", "additionalAttr": "Hello" } ]

Gemeinsame Elemente zweier Arrays finden

Gibt alle Werte zurück, die sowohl im Array array als auch im Array compareArray enthalten sind.

Input:

{ "array": [1, 2, 5, 6], "compareArray": [1, 2, 3] }

JSONata Expression:

[$filter($.array, function($v, $i, $a) { $exists($$.compareArray[$v = $]) })]

Output:

[1, 2]

Array von Zahlenbereich erzeugen

Erstellt ein Array von Objekten mit fortlaufenden Werten zwischen start und end.

Input:

{ "start": 1, "end": 3 }

JSONata Expression:

[$map([($$.start)..($$.end)], function($v) { { "value": $v } })]

Output:

[ { "value": 1 }, { "value": 2 }, { "value": 3 } ]

Dynamisches SQL für Urlaubsüberschneidungen erzeugen

Generiert ein SQL-Statement, das für einen Zeitraum rund um den beantragten Urlaub pro Tag eine CASE WHEN-Abfrage erstellt. Damit lassen sich Urlaubsüberschneidungen mit bestehenden Anträgen prüfen.

Input:

{ "urlaub_von": "2025-12-12", "urlaub_bis": "2025-12-14" }

JSONata Expression:

``` ( $oneDay := 86400000;

$startDate := $toMillis(urlaub_von) - (4 * $oneDay); $endDate := $toMillis(urlaub_bis) + (4 * $oneDay);

$days := $map( $spread([0..$floor(($endDate - $startDate) / $oneDay)]), function($i) { $fromMillis($startDate + ($i * $oneDay), "[Y0001]-[M01]-[D01]") } );

$cases := $map( $days, function($day) { "CASE WHEN DATE '" & $day & "' BETWEEN urlaub_von AND urlaub_bis THEN 'X' ELSE '' END AS \"" & $day & "\"" } );

"SELECT p.document_name AS antragsteller, " & $join($cases, ", ") & " FROM urlaubsantrag_only u JOIN person p ON u.antragsteller = p.id" & " WHERE urlaub_von <= DATE '" & urlaub_bis & "' AND urlaub_bis >= DATE '" & urlaub_von & "'" & " ORDER BY p.document_name" ) ```

Output:

sql SELECT p.document_name AS antragsteller, CASE WHEN DATE '2025-12-08' BETWEEN urlaub_von AND urlaub_bis THEN 'X' ELSE '' END AS "2025-12-08", CASE WHEN DATE '2025-12-09' BETWEEN urlaub_von AND urlaub_bis THEN 'X' ELSE '' END AS "2025-12-09", ... FROM urlaubsantrag_only u JOIN person p ON u.antragsteller = p.id WHERE urlaub_von <= DATE '2025-12-14' AND urlaub_bis >= DATE '2025-12-12' ORDER BY p.document_name

Troubleshooting

Expression wird nicht ausgeführt

Ursache: Syntaxfehler in der JSONata-Expression

Lösung:

Teste die Expression im Pantarey JSONata-Editor (im Prozess Designer)
Alternativ: try.jsonata.org
Prüfe auf fehlende Klammern oder Kommas
Achte auf korrekte Pfadangaben (z. B. $.customer.name)

Ergebnis ist leer oder undefined

Ursache: Der angegebene Pfad existiert nicht in den Prozessdaten

Lösung: - Prüfe die Prozessdaten im Prozess-Explorer - Es wird verwendet $exists($.field) um zu testen, ob ein Feld existiert - Es wird genutzt Fallback-Werte: $.field ? $.field : "default"

Output wird nicht in Prozessvariable gespeichert

Ursache: Ergebnispfad (Result Path) ist leer oder falsch definiert

Lösung: - Stelle sicher, dass der Ergebnispfad einen gültigen Pfad enthält - Aussagekräftige Namen (z. B. result.customer_data) - Mehr Informationen: Ergebnispfad - Deploy den Prozess neu

FAQ – Häufige Fragen zu Input/Output

Muss ich immer JSONata verwenden?
Ja, aber JSONata kann sehr einfach sein. Ein einfacher Feldverweis wie $.order_id oder ein simples JSON-Objekt { "id": $.order_id } ist bereits gültiges JSONata. Komplexe Transformationen mit Funktionen wie $map() oder $filter() werden nur bei Bedarf eingesetzt.

Kann ich mehrere Felder im Output zurückgeben?
Ja. Es wird verwendet ein Objekt als Output:

{
  "status": $.status,
  "total": $.total
}

Wie Zugriff auf verschachtelte Objekte zu?
Mit der Punkt-Notation: $.customer.address.city

Kann ich Arrays transformieren?
Ja, mit $map(): $map($.items, function($item) { $item.price * 1.19 })

Mehr zur Array-Verarbeitung in der JSONata Dokumentation zu Arrays.

Was ist der Unterschied zwischen Input-Parameter, Output-Parameter und Ergebnispfad?

Input-Parameter: Welche Daten gehen in die Aktivität rein (Quelle)
Output-Parameter: Wie wird das Ergebnis transformiert (WAS)
Ergebnispfad: Wo wird das transformierte Ergebnis gespeichert (WO)

Mehr dazu: Ergebnispfad (Result Path)

Können Input-Expressions auf vorherige Task-Ergebnisse zugreifen?
Ja, über die Prozessvariablen. Wenn Task A sein Ergebnis unter resultA gespeichert hat, kann Task B mit $.resultA darauf zugreifen.

Weiterführende Informationen

JSONata Dokumentation

Pantarey JSONata-Editor – Im Prozess Designer integriert für Live-Testing
Offizielle JSONata Dokumentation
JSONata Playground
JSONata Exerciser

Nächste Schritte

Mehr über Prozesse erstellen erfahren
Service Tasks mit Input/Output nutzen
Deployment von Prozessen durchführen

Input und Output einer Aktivität

Übersicht

Kurz zusammengefasst

Grundkonzept

Input-Parameter

Output-Parameter

JSONata – Transformation von Daten

Grundlegende Syntax

Wichtige Funktionen

Anwendung in Pantarey

Im Prozess Designer

Typische Szenarien

Best Practices

Input-Parameter

Output-Parameter

JSONata-Expressions

Praxisbeispiele

Troubleshooting

Expression wird nicht ausgeführt

Ergebnis ist leer oder undefined

Output wird nicht in Prozessvariable gespeichert

FAQ – Häufige Fragen zu Input/Output

Weiterführende Informationen

JSONata Dokumentation

Verwandte Themen

Nächste Schritte