---
title: "Aufgabenformulare"
description: "Ein Aufgabenformular enthält die Fragen, die eine Person beantwortet, um eine Aufgabe abzuschließen: eine Palettenzahl, eine Checkbox, ein Foto. Orbit prüft jede Antwort gegen das Formular, bevor die Aufgabe als erledigt gilt."
url: "https://support.pr-4.orbit.do/de/tasks/task-forms"
locale: "de"
lastReviewed: "2026-09-30"
---

# Aufgabenformulare

Ein Aufgabenformular enthält die Fragen, die eine Person beantwortet, um eine Aufgabe abzuschließen: eine Palettenzahl, eine Checkbox, ein Foto. Orbit prüft jede Antwort gegen das Formular, bevor die Aufgabe als erledigt gilt.

## Überblick

Viele Aufgaben brauchen mehr als eine Bestätigung. Ein **Aufgabenformular** beschreibt genau, was die Person eingeben muss, in welcher Reihenfolge und unter welchen Bedingungen. Dasselbe Formular funktioniert in jeder App, daher beantworten ein Fahrer (Driver) in Orbit Cockpit und ein Operator in Orbit MissionControl dieselben Fragen und erzeugen dasselbe Ergebnis.

Ein Formular ist optional. Eine Aufgabe ohne Formular wird mit einer einzigen Bestätigung abgeschlossen. Was eine Aufgabe ist und wie sie ihre Status durchläuft, lesen Sie unter [Aufgaben](https://support.pr-4.orbit.do/de/tasks/tasks).

**Das Wichtigste:**

* **Neun Feldtypen:** Zahlen, Text, Checkboxen, Auswahlen, Datum, Datum mit Uhrzeit, Dateien und Fotos sowie statischer Infotext
* **Bis zu 10 Schritte:** Lange Formulare teilen sich auf Seiten auf, optional mit einer Zusammenfassung am Ende
* **Bedingungen:** Ein Schritt oder Feld erscheint nur, wenn eine frühere Antwort es verlangt
* **Fotos und Dateien:** mehrere Dateien je Feld, in Orbit Cockpit zuerst mit der Kamera
* **Platzhalter und Vorbelegungen:** Formulartexte und Standardantworten können Daten der Tour, des Stopps (Stop) oder des Shipments enthalten
* **Beim Abschluss geprüft:** Orbit prüft jede Antwort und lässt die Aufgabe offen, bis das Formular stimmt

## Wo Formulare ausgefüllt werden

Die Person, der die Aufgabe zugewiesen ist, füllt das Formular in ihrer eigenen App aus:

* **Orbit MissionControl:** im Aufgabenfenster. Siehe [Aufgaben in Orbit MissionControl](https://support.pr-4.orbit.do/de/tasks/tasks-in-orbit-missioncontrol).
* **Orbit Cockpit:** in der Aufgabenansicht, die sich am Stopp oder an der Tour öffnet. Siehe [Aufgaben in Orbit Cockpit](https://support.pr-4.orbit.do/de/tasks/tasks-in-orbit-cockpit).
* **Orbit Connect:** im Aufgabendialog. Siehe [Aufgaben in Orbit Connect](https://support.pr-4.orbit.do/de/tasks/tasks-in-orbit-connect).

Ein Formular mit mehreren Schritten zeigt seinen Fortschritt (**Schritt 2 von 3**) und geht in Orbit MissionControl, Orbit Connect und Orbit Cockpit mit **Weiter** zum nächsten Schritt. Der letzte Schritt endet mit **Absenden**. Nach dem Abschluss bleiben die Antworten in der Aufgabe lesbar, markiert als **Abgeschlossen**.

## Feldtypen

Jedes Feld in einem Formular hat einen `kind`. Alle Eingabefelder teilen diese Einstellungen: `id` (eindeutig im Formular, die Antworten werden darunter gespeichert), `label`, eine optionale `description`, die als Hilfetext erscheint, `required` und eine optionale Bedingung, `visibleIf`.

| Kind           | Was die Person sieht               | Antwort wird gespeichert als  | Weitere Einstellungen                 | Validatoren                      |
| -------------- | ---------------------------------- | ----------------------------- | ------------------------------------- | -------------------------------- |
| `number`       | Ein Zahlenfeld                     | Zahl                          | `placeholder`, `preset`               | `range`, `integer`, `http-json`  |
| `text`         | Ein einzeiliges Textfeld           | Text                          | `placeholder`, `preset`               | `pattern`, `length`, `http-json` |
| `textarea`     | Ein mehrzeiliges Textfeld          | Text                          | `placeholder`, `preset`               | `pattern`, `length`, `http-json` |
| `checkbox`     | Eine einzelne Checkbox             | `true` oder `false`           | `preset`                              | Keine                            |
| `select`       | Eine Auswahl von Optionen          | Die `id` der gewählten Option | `options` (mindestens eine), `preset` | Keine                            |
| `date`         | Eine Datumsauswahl                 | Datum als `YYYY-MM-DD`        | `preset`                              | Keine                            |
| `datetime`     | Eine Auswahl für Datum und Uhrzeit | Zeitpunkt in Epoch-Sekunden   | `preset`                              | Keine                            |
| `file`         | Upload-Bereich oder Kamera         | Eine Liste von Dokument-IDs   | `maxFiles`, `acceptedContentTypes`    | Keine                            |
| `display-text` | Statischer Text, keine Eingabe     | Nichts                        | `text` statt `label`                  | Keine                            |

Labels, Beschreibungen und Optionsnamen werden je Sprache geschrieben, zum Beispiel `{ "en": "Pallets delivered", "de": "Gelieferte Paletten" }`. Mindestens eine Sprache muss ausgefüllt sein.

Eine Checkbox antwortet immer mit **Ja** oder **Nein**. Eine nicht angehakte Checkbox zählt als **Nein**, daher erzwingt `required` an einer Checkbox nie einen Haken. Wenn eine Person etwas ausdrücklich bestätigen muss, verwenden Sie ein Pflichtfeld `select` mit einer einzigen Option wie **Bestätigt**.

### Validatoren

Validatoren fügen Regeln über `required` hinaus hinzu. Jedes Feld nimmt bis zu 10 davon, und jeder kann in `localizedMessage` eine eigene Fehlermeldung tragen.

| Validator   | Regel                                                                       |
| ----------- | --------------------------------------------------------------------------- |
| `pattern`   | Der Text muss vollständig zu einem regulären Ausdruck passen                |
| `length`    | Der Text hat mindestens `min` und höchstens `max` Zeichen                   |
| `range`     | Die Zahl liegt zwischen `min` und `max`, beide eingeschlossen               |
| `integer`   | Die Zahl ist eine ganze Zahl                                                |
| `http-json` | Ihr eigenes System prüft den Wert beim Abschluss (siehe Technische Details) |

## Schritte

Ein Formular besteht aus einem oder mehreren Schritten, höchstens 10. Jeder Schritt hat eine `id`, einen optionalen `title` und seine Felder. Ein Formular enthält über alle Schritte bis zu 50 Felder. Ein Formular mit nur einem Schritt zeigt keine Fortschrittsanzeige und geht direkt zu **Absenden**.

### Der Zusammenfassungsschritt

Setzen Sie `summaryStep` auf `true`, um eine letzte Seite **Zusammenfassung** hinzuzufügen. Sie listet jede Antwort für eine letzte Kontrolle, bevor die Person absendet. **Bearbeiten** neben einem Schritt springt zu ihm zurück. Lehnt Orbit beim Absenden eine Antwort ab, markiert die Zusammenfassung das Feld und verlinkt auf seinen Schritt.

![Der Zusammenfassungsschritt eines Aufgabenformulars in Orbit Cockpit, mit einem Link zum Bearbeiten je Schritt](https://support.pr-4.orbit.do/images/task-forms/03-cockpit-form-summary.png)

*Der Zusammenfassungsschritt in Orbit Cockpit: jede Antwort auf einen Blick vor dem Absenden.*

## Bedingungen

Eine Bedingung zeigt einen Schritt oder ein Feld nur, wenn eine frühere Antwort es verlangt. Eine Schadensbeschreibung erscheint nur, wenn der Fahrer einen Schaden meldet. Ein Fotoschritt erscheint nur, wenn Paletten fehlen.

Bedingungen stehen in `visibleIf`. Sie vergleichen ein früheres Feld mit einem festen Wert und verbinden mehrere Vergleiche mit `and` oder `or`:

```json
"visibleIf": {
  "combinator": "and",
  "rules": [{ "field": "condition", "operator": "=", "value": "damaged" }]
}
```

Diese Vergleiche sind möglich:

| Früheres Feld ist ein | Operatoren                      | Vergleich mit         |
| --------------------- | ------------------------------- | --------------------- |
| `checkbox`            | `=`, `!=`                       | `true` oder `false`   |
| `select`              | `=`, `!=`                       | Der `id` einer Option |
| `number`              | `=`, `!=`, `<`, `<=`, `>`, `>=` | Einer Zahl            |
| `text`                | `=`, `contains`                 | Einem Text            |

Ein paar Regeln halten Bedingungen vorhersehbar:

* Eine Bedingung kann sich nur auf Felder beziehen, die **früher** im Formular kommen. Eine Schrittbedingung bezieht sich auf Felder in früheren Schritten.
* Felder der Arten `textarea`, `date`, `datetime` und `file` lassen sich nicht in einer Bedingung verwenden.
* Ein ausgeblendetes Feld ist nie Pflicht. Seine Antwort wird nicht gesendet, und Orbit lehnt einen Wert dafür ab.
* Eine Bedingung enthält höchstens 20 Vergleiche.

## Fotos und Dateien

Ein Feld `file` sammelt Fotos, PDFs oder andere Dokumente. Ein Feld kann mehrere Dateien aufnehmen: standardmäßig bis zu 10 und mit `maxFiles` bis zu 50. Über das ganze Formular ist die Summe aller `maxFiles`-Werte auf 200 begrenzt. Ein Pflichtfeld für Dateien braucht mindestens eine Datei.

* **`acceptedContentTypes`** listet die Dateitypen, die angeboten werden, zum Beispiel `["image/jpeg", "application/pdf"]`. Die Apps zeigen in der Dateiauswahl nur diese Typen, und Orbit Cockpit lehnt andere Typen mit **Dateityp nicht erlaubt** ab.

Orbit Cockpit bietet bei jedem Feld, das JPEG-Bilder annimmt, zuerst **Foto aufnehmen** an und als zweite Möglichkeit **Aus Galerie wählen** oder **Datei wählen**. Die Kamera speichert Fotos als JPEG, daher zeigt ein Feld, das auf PNG beschränkt ist, keine Kamera-Schaltfläche.

Jede Datei wird hochgeladen, sobald sie hinzugefügt ist. **Absenden** wartet, bis jeder Upload fertig ist. Die Dateien werden als Dokumente an der Aufgabe gespeichert.

![Ein Formularschritt mit einem Fotofeld in Orbit Cockpit](https://support.pr-4.orbit.do/images/task-forms/03-cockpit-form-photo.png)

*Ein Fotofeld in Orbit Cockpit: Der Fahrer nimmt bis zur erlaubten Anzahl Fotos auf und kann sie vor dem Absenden entfernen oder neu aufnehmen.*

## Platzhalter und Vorbelegungen

Formulartexte können Daten des Objekts enthalten, zu dem die Aufgabe gehört, zum Beispiel seiner Tour, seines Stopps oder seines Shipments. Schreiben Sie einen Platzhalter in doppelten geschweiften Klammern, zum Beispiel `{{ tour.displayName }}` oder `{{ stop.address.companyName }}`. In einer [Aufgabenvorlage](https://support.pr-4.orbit.do/de/tasks/task-templates) entscheidet der Auslöser, welche Daten verfügbar sind. Orbit ersetzt die Platzhalter einmal, wenn es die Aufgabe anlegt.

Platzhalter funktionieren in Schritttiteln, Feldlabels, Beschreibungen, Platzhaltertexten, Optionsnamen, Validatormeldungen und Anzeigetext.

Ein `preset` füllt eine Standardantwort vor, die die Person ändern kann. Sie kann fest sein (`0`, `true`, eine Options-`id`) oder aus einem Platzhalter kommen. Passt eine Vorbelegung nicht zum Feld, zum Beispiel Text in einem Zahlenfeld, lässt Orbit das Feld leer, statt die Aufgabe anzuhalten. Felder `file` nehmen keine Vorbelegung.

## Ein Formular bearbeiten

Formulare gehören zu einer Aufgabenvorlage und werden in Orbit MissionControl bearbeitet. Die vollständige Einrichtung einer Vorlage beschreibt [Aufgabenvorlagen](https://support.pr-4.orbit.do/de/tasks/task-templates).

1. Öffnen Sie in Orbit MissionControl die Aufgabenvorlage.
2. Wählen Sie den Tab **Formular**.
3. Bearbeiten Sie das Formular als JSON im Editor links.

Wenn Sie eine Vorlage anlegen, bietet **Womit beginnt das Formular?** einen Ausgangspunkt: **Kein Formular**, **Checkliste** oder **Fotonachweis mit Kommentar**.

Der Editor schlägt beim Tippen Schlüssel vor, listet Platzhalter unter **Verfügbare Daten** und markiert Fehler direkt im Text. Eine Statuszeile zeigt die Zahl der Schritte und Elemente oder die Zahl der Fehler. Die Vorschau rechts zeigt das Formular so, wie der Empfänger es sieht, gefüllt mit Beispieldaten. Füllen Sie es aus, um die Antworten unter **Ausgabe** zu sehen. Speichern können Sie erst, wenn jeder Fehler behoben ist.

Eine Aufgabe behält das Formular, mit dem sie angelegt wurde. Änderungen an einer Vorlage gelten für Aufgaben, die danach entstehen.

## Beispielformular

Dieses Formular prüft einen Palettentausch an jedem Stopp. Der Fahrer gibt die Zahl der gelieferten Paletten ein und ob alle getauscht wurden. Fehlen einige oder alle, fragt ein zweiter Schritt nach den erhaltenen Leerpaletten und einem Foto des Palettenscheins. Eine Zusammenfassung schließt das Formular ab.

```json
{
  "summaryStep": true,
  "steps": [
    {
      "id": "count",
      "title": { "en": "Pallet count" },
      "elements": [
        {
          "id": "intro",
          "kind": "display-text",
          "text": {
            "en": "Count the Euro pallets you exchange with {{ stop.address.companyName }}."
          }
        },
        {
          "id": "palletsDelivered",
          "kind": "number",
          "label": { "en": "Pallets delivered" },
          "required": true,
          "validation": [
            { "type": "integer" },
            { "type": "range", "min": 0, "max": 66 }
          ]
        },
        {
          "id": "exchange",
          "kind": "select",
          "label": { "en": "Pallets exchanged?" },
          "required": true,
          "preset": "full",
          "options": [
            { "id": "full", "localizedName": { "en": "All exchanged" } },
            { "id": "partial", "localizedName": { "en": "Some missing" } },
            { "id": "none", "localizedName": { "en": "None exchanged" } }
          ]
        }
      ]
    },
    {
      "id": "shortfall",
      "title": { "en": "Missing pallets" },
      "visibleIf": {
        "combinator": "or",
        "rules": [
          { "field": "exchange", "operator": "=", "value": "partial" },
          { "field": "exchange", "operator": "=", "value": "none" }
        ]
      },
      "elements": [
        {
          "id": "palletsReturned",
          "kind": "number",
          "label": { "en": "Empty pallets received" },
          "required": true,
          "preset": 0,
          "validation": [{ "type": "integer" }]
        },
        {
          "id": "photos",
          "kind": "file",
          "label": { "en": "Photo of the pallet note" },
          "required": true,
          "maxFiles": 3,
          "acceptedContentTypes": ["image/jpeg", "image/png"]
        }
      ]
    }
  ]
}
```

Der Platzhalter `{{ stop.address.companyName }}` braucht eine Vorlage mit dem Auslöser **Je Stopp einer Tour**.

## Beispiel

Spaceport Shipping Co. liefert Baustoffe in ganz Rotterdam aus und tauscht bei jeder Entladung Europaletten. Die Operatorin Julia fügt das Palettentausch-Formular oben einer Aufgabenvorlage für jeden Stopp hinzu. An einer Baustelle gibt der Fahrer Mohammad 12 gelieferte Paletten ein und wählt **Some missing**. Der Schritt **Missing pallets** erscheint, er gibt 8 erhaltene Leerpaletten ein und fotografiert den unterschriebenen Palettenschein. In der Zusammenfassung prüft er die Zahlen und tippt auf **Absenden**. In Orbit MissionControl öffnet Julia die abgeschlossene Aufgabe und sieht die Zahl, die Fehlmenge und das Foto.

## Technische Details

Aufgaben mit Formular lassen sich auch über die Orbit API anlegen und abschließen. Das Formular reist als JSON in derselben Form wie im Vorlagen-Editor, und die Antworten werden als Objekt gesendet, dessen Schlüssel die `id` der Felder sind. Eine Dateiantwort ist immer eine Liste von Dokument-IDs, auch bei einer einzelnen Datei. Laden Sie die Dateien zuerst hoch und senden Sie ihre IDs mit dem Abschluss. Platzhalter in einem Formular, das über die API kommt, werden gegen das Objekt aufgelöst, zu dem die Aufgabe gehört.

Die Liste `acceptedContentTypes` dient den Apps als Vorgabe. Die API setzt sie nicht durch.

Ein Validator `http-json` sendet den Wert beim Abschluss der Aufgabe an eine HTTPS-Adresse Ihres eigenen Systems, nachdem jede andere Prüfung bestanden ist. Ihr System nimmt den Wert an oder lehnt ihn ab. Lehnt es ihn ab oder antwortet es nicht innerhalb von 5 Sekunden, bleibt die Aufgabe offen. Ein Formular kann bis zu 8 dieser Validatoren verwenden.

Abgeschlossene Antworten sind Teil des Webhooks `task-completed`, und eine Vorlage der [Document Engine](https://support.pr-4.orbit.do/de/advanced-features/document-engine) kann sie drucken, Fotos eingeschlossen. Endpunkte und Schemas finden Sie in der [Orbit API Reference](https://orbit-api.readme.io).

## FAQ

**Q: Können Fahrer mehrere Fotos an ein Feld hängen?**

Ja. Ein Dateifeld nimmt standardmäßig bis zu 10 Dateien an. Setzen Sie `maxFiles`, um bis zu 50 zu erlauben.

**Q: Was passiert mit den Antworten?**

Orbit speichert sie mit der abgeschlossenen Aufgabe. Sie bleiben in der Aufgabe in Orbit MissionControl und Orbit Cockpit lesbar, sind Teil des Webhooks `task-completed`, und eine Dokumentvorlage, die mit der Aufgabenvorlage verknüpft ist, kann sie drucken.

**Q: Was passiert, wenn eine Antwort falsch ist?**

Orbit prüft das Formular, bevor es die Aufgabe abschließt. Verstößt eine Antwort gegen eine Regel, bleibt die Aufgabe offen, und die App markiert das Feld mit dem Grund.

**Q: Kann ich das Formular einer bestehenden Aufgabe ändern?**

Nein. Eine Aufgabe behält das Formular, mit dem sie angelegt wurde. Ändern Sie die Aufgabenvorlage, dann verwenden neue Aufgaben das neue Formular.

**Q: Kann eine Bedingung von einem späteren Feld abhängen?**

Nein. Eine Bedingung kann sich nur auf Felder beziehen, die früher im Formular kommen. So beantwortet die Person die entscheidende Frage immer zuerst.
