Kontrollfluss

Was Kontrollfluss bedeutet

Ein Workflow ist normalerweise eine einfache Liste von Schritten, die nacheinander von oben nach unten abgearbeitet werden. Der Kontrollfluss sind die wenigen eingebauten Sprach-Elemente, mit denen Sie diese strikte Reihenfolge durchbrechen: Sie können je nach Situation verzweigen, etwas wiederholen, Dinge gleichzeitig erledigen, Fehler auffangen, eine Pause einlegen oder den Workflow vorzeitig beenden.

Diese Elemente sind keine Module, sondern fester Bestandteil der Sprache. Es ist ein kleines, überschaubares Vokabular, und alle Schlüsselwörter sind durchgehend deutsch. Im grafischen Editor erscheinen die Verzweigungen und Schleifen als Spuren und Verschachtelungen, im YAML als eingerückte Blöcke. Beides beschreibt denselben Ablauf.

• wenn / dann / sonst — Verzweigung: unterschiedliche Wege je nach Bedingung
• für-jede — Schleife: denselben Ablauf für jeden Eintrag einer Liste wiederholen
• parallel — mehrere unabhängige Zweige gleichzeitig ausführen
• versuche / bei_fehler — Auffangnetz für Fehler
• warte — eine Pause einlegen
• aufruf — einen anderen Workflow als Baustein aufrufen
• abbruch — den Workflow vorzeitig sauber beenden

Verzweigen mit wenn / dann / sonst

Mit wenn entscheidet der Workflow je nach Situation, welchen Weg er nimmt. Trifft die Bedingung zu, läuft der dann-Zweig; trifft sie nicht zu, läuft der sonst-Zweig (der sonst-Zweig ist optional). Im Editor sehen Sie das als zwei Spuren nebeneinander: links der Ja-Weg, rechts der Nein-Weg.

Bedingungen werden in Flower nicht als Rechen-Ausdruck geschrieben, sondern strukturiert aus einer Variable und einem Operator-Schlüssel. Das hält die Bedingungen lesbar und für die KI gut erzeugbar. Mehrere Bedingungen lassen sich mit alle (alle müssen zutreffen, UND) oder eine (mindestens eine muss zutreffen, ODER) verknüpfen.

• ist / ist-nicht — gleich bzw. ungleich
• größer-als / kleiner-als — für Zahlen und Datumswerte
• enthält — Text enthält Teiltext, Liste enthält Element, Map enthält Schlüssel
• ist-leer — Variable existiert, ist aber leer (Wert wahr/falsch)
• existiert — Variable ist überhaupt gesetzt (Wert wahr/falsch)
• alle: / eine: — mehrere Bedingungen als UND bzw. ODER verknüpfen

ablauf:
  - wenn:
      variable: kunde_neu
      ist: wahr
    dann:
      - office.outlook.mail:
          an:      kunde.email
          betreff: "Willkommen"
          text:    willkommens_text
          aktionen:
            - senden
    sonst:
      - benachrichtigung:
          aktionen:
            - anzeigen: { text: "Bestand-Kunde, übersprungen" }

Wiederholen mit für-jede

Mit für-jede wiederholen Sie denselben Ablauf für jeden Eintrag einer Liste (oder Map). In jedem Durchlauf steht der aktuelle Eintrag unter einem von Ihnen gewählten Namen zur Verfügung, optional auch ein Zähl-Index. Der Schleifen-Körper steht unter tue.

Die Schleifen-Variable ist nur innerhalb der Schleife sichtbar. Werte aus dem äußeren Workflow dürfen Sie lesen, aber nicht von innen heraus überschreiben — das verhindert schwer auffindbare Fehler, besonders bei paralleler Ausführung. Wenn Sie Ergebnisse aus den Durchläufen mitnehmen möchten, sammeln Sie diese mit sammle in eine Ergebnis-Liste.

Standardmäßig laufen die Durchläufe nacheinander. Mit parallel: ja laufen mehrere gleichzeitig (Anzahl über gleichzeitig steuerbar). Über bei-fehler entscheiden Sie, ob ein Fehler in einem Durchlauf die ganze Schleife stoppt (stoppen, Standard) oder ob der betroffene Durchlauf übersprungen und der Fehler nur vermerkt wird (weiter).

• in: — die Liste oder Map, über die iteriert wird
• als: — Name des aktuellen Eintrags im Schleifen-Körper
• index: — optionaler 0-basierter Zähler
• parallel: ja + gleichzeitig: N — Durchläufe gleichzeitig ausführen
• bei-fehler: stoppen | weiter — Verhalten bei einem Fehler im Durchlauf
• sammle: — Werte aus den Durchläufen in eine Ergebnis-Liste übernehmen

ablauf:
  - für-jede:
      in: pdf_dateien
      als: pdf
      tue:
        - aufruf: "pdf-zu-excel.flower"
          inputs: { pdf_pfad: pdf }

Gleichzeitig arbeiten mit parallel

Mit parallel laufen mehrere unabhängige Zweige zur gleichen Zeit. Das eignet sich, wenn unterschiedliche Aufgaben nichts voneinander wissen müssen — etwa gleichzeitig Daten aus Excel laden und Angebote von einer Webschnittstelle holen. Jeder Zweig bekommt einen Namen und einen eigenen Ablauf unter tue.

Wichtig ist der Unterschied zu für-jede mit parallel: ja. parallel ist für unterschiedliche Aufgaben gedacht; mehrere gleichartige Durchläufe über dieselben Daten gehören in eine für-jede-Schleife mit parallel: ja.

Jeder Zweig hat einen abgeschotteten Bereich. Ergebnisse eines Zweigs erreichen den Hauptablauf über zweig.<name>.<variable>. Mit bei-fehler legen Sie fest, ob bei einem Fehler alle Zweige zu Ende laufen (alle-warten, Standard) oder die übrigen sofort abgebrochen werden (sofort-stoppen).

• zweige: — Liste der gleichzeitig laufenden Zweige, je mit name und tue
• Ergebnis-Zugriff im Hauptablauf über zweig.<name>.<variable>
• bei-fehler: alle-warten | sofort-stoppen
• Für viele gleichartige Daten-Durchläufe stattdessen für-jede mit parallel: ja nutzen

ablauf:
  - parallel:
      bei-fehler: alle-warten
      zweige:
        - name: kunden-laden
          tue:
            - office.excel:
                datei: kunden_excel
                aktionen:
                  - bereich-lesen: { bereich: "A2:C100", ergebnis: kunden }
        - name: angebote-laden
          tue:
            - http:
                aktionen:
                  - get:
                      url: "https://api.firma.de/angebote"
                      ergebnis: angebote

Fehler auffangen mit versuche / bei_fehler

Standardmäßig stoppt ein Workflow sofort, sobald ein Schritt einen Fehler wirft — der Lauf endet mit Status Fehler und wird protokolliert. Offene Modul-Sitzungen wie Excel oder Outlook werden dabei sauber geschlossen.

Mit versuche umgeben Sie heikle Schritte mit einem Auffangnetz. Schlägt darin etwas fehl, wird der Fehler gefangen und der bei_fehler-Block ausgeführt, statt den ganzen Workflow zu beenden. Innerhalb dieses Blocks steht die Variable fehler mit Details zur Verfügung — und nur dort: nach dem Block ist sie wieder weg, damit spätere Schritte nicht versehentlich auf einen längst behandelten Fehler reagieren.

So lässt sich gezielt reagieren, etwa bei einem Netzwerkfehler kurz warten und erneut versuchen, sonst eine Meldung anzeigen und mit abbruch beenden. Löst der bei_fehler-Block das Problem nicht und soll der Workflow trotzdem stoppen, beenden Sie ihn ausdrücklich mit abbruch — ein automatisches Weiterreichen verschachtelter Fehler gibt es bewusst nicht.

• fehler.nachricht — mensch-lesbarer Fehlertext
• fehler.modul / fehler.aktion — wo es passierte
• fehler.typ — Kategorie wie netzwerk, datei-nicht-gefunden, auth, nicht-verfügbar
• fehler.zeitpunkt — wann es passierte
• fehler.details — modul-spezifische Strukturdaten (z.B. HTTP-Status, Pfad)
• Ein nicht gefangener Fehler in einem aufgerufenen Workflow wird an den Aufrufer weitergereicht und ist dort fangbar

ablauf:
  - versuche:
      - office.outlook.mail:
          an:      kunde.email
          betreff: "Bestätigung"
          text:    nachricht
          aktionen:
            - senden
    bei_fehler:
      - wenn:
          variable: fehler.typ
          ist: "netzwerk"
        dann:
          - warte: 30s
          - aufruf: "diesen-workflow-erneut.flower"
        sonst:
          - benachrichtigung:
              titel: "Mail nicht versendet"
              text:  fehler.nachricht
              aktionen:
                - anzeigen
          - abbruch

Pausieren mit warte und Beenden mit abbruch

warte legt eine Pause ein, bevor es weitergeht — etwa um einer langsamen Gegenstelle Zeit zu geben oder vor einem erneuten Versuch durchzuatmen. Die Dauer wird in der gewohnten Zeitspannen-Schreibweise angegeben, zum Beispiel 30s, 5m oder 2h.

Kurze Wartezeiten sitzt der Workflow einfach aus. Längere Wartezeiten (ab etwa einer Minute) werden gespeichert und der laufende Prozess wird beendet — der Hintergrund-Dienst nimmt den Lauf zum richtigen Zeitpunkt automatisch genau an der Stelle wieder auf, an der er pausiert hat. Das spart Ressourcen und übersteht sogar einen Neustart.

abbruch beendet den Workflow vorzeitig und sauber. Es ist die ausdrückliche Variante, einen Lauf zu stoppen — etwa im sonst-Zweig einer Fehlerbehandlung, wenn keine sinnvolle Fortsetzung mehr möglich ist.

• warte: 30s — kurze Pause, wird in-process ausgesessen
• warte: 2h — lange Pause, wird gespeichert und übersteht einen Neustart
• abbruch — beendet den Workflow vorzeitig und sauber
• Zeitspannen-Schreibweise: s = Sekunden, m = Minuten, h = Stunden

ablauf:
  - warte: 1m
  - aufruf: "status-pruefen.flower"