Erweitern der Workflow-Funktionen extending-workflow-functionality

Hier wird beschrieben, wie Sie benutzerdefinierte Schritt-Komponenten für Ihre Workflows entwickeln und wie Sie programmatisch mit Workflows interagieren.

Die Erstellung eines benutzerdefinierten Workflow-Schritts umfasst die folgenden Aktivitäten:

Sie können auch mit Ihren Workflows aus Ihren Programmen und Skripten interagieren.

Workflow-Schritt-Komponenten - Grundlagen workflow-step-components-the-basics

Eine Workflow-Schritt-Komponente definiert das Erscheinungsbild und Verhalten des Schritts beim Erstellen von Workflow-Modellen:

Wie alle Komponenten erben Workflow-Schritt-Komponenten von der Komponente, die für die Eigenschaft sling:resourceSuperType festgelegt ist. Das folgende Diagramm zeigt die Hierarchie von cq:component-Knoten, die die Grundlage aller Workflow-Schritt-Komponenten bilden. Das Diagramm enthält auch die Komponenten Prozess-Schritt, Teilnehmer-Schritt und Dynamischer-Teilnehmer-Schritt, da sie die gängigsten (und grundlegendsten) Ausgangspunkte für die Entwicklung angepasster Schritt-Komponenten darstellen.

Die Komponente /libs/cq/workflow/components/model/step ist der nächste gemeinsame Vorgänger von Prozess-Schritt, Teilnehmer-Schritt und Dynamischer-Teilnehmer-Schritt, die alle die folgenden Elemente erben:

ECMA-Skripte ecma-scripts

Die folgenden Objekte sind (abhängig vom Schritttyp) bei ECMA-Skripten verfügbar:

MetaDataMaps metadatamaps

Sie können Workflow-Metadaten verwenden, um Informationen beizubehalten, die während der Lebensdauer des Workflows benötigt werden. Eine gängige Anforderung an Workflow-Schritte besteht darin, Daten für die zukünftige Verwendung im Workflow beizubehalten oder die gespeicherten Daten abzurufen.

Es gibt drei Typen von MetaDataMap-Objekten – für Workflow-, WorkflowData- und WorkItem-Objekte. Sie alle sollen demselben Zweck dienen- dem Speichern von Metadaten.

Ein WorkItem verfügt über seine eigene MetaDataMap, die nur verwendet werden kann, während das WorkItem (z. B. der Schritt) ausgeführt wird.

Die MetaDataMaps von Workflow sowie von WorkflowData werden über den gesamten Workflow hinweg gemeinsam verwendet. In diesen Fällen empfiehlt es sich, nur die MetaDataMap von WorkflowData zu nutzen.

Erstellen benutzerdefinierter Workflow-Schrittkomponenten creating-custom-workflow-step-components

Workflow-Schritt-Komponenten können auf die gleiche Weise erstellt wie jede andere Komponente.

Für das Erben von einer der (vorhandenen) Basis-Schritt-Komponenten fügen Sie die folgende Eigenschaft zum Knoten cq:Component hinzu:

Angeben des Standardtitels und der Beschreibung für Schrittinstanzen specifying-the-default-title-and-description-for-step-instances

Gehen Sie wie folgt vor, um Standardwerte für die Titel und Beschreibung -Felder auf Häufig Registerkarte.

Speichern von Eigenschaftswerten in Workflow-Metadaten saving-property-values-in-workflow-metadata

Die name-Eigenschaft von cq:Widget-Elementen gibt den JCR-Knoten an, der den Wert des Widgets speichert. Wenn Widgets im Dialog der Schrittkomponenten des Workflows Werte unterhalb des Knotens ./metaData speichern, wird der Wert zum Workflow MetaDataMap hinzugefügt.

Beispiel: Ein Textfeld in einem Dialogfeld ist ein cq:Widget-Knoten mit den folgenden Eigenschaften:

Der Wert, der in diesem Textfeld festgelegt wird, wird zum [MetaDataMap](#metadatamaps)-Objekt der Workflow-Instanz hinzugefügt und mit dem subject-Schlüssel verknüpft.

Überschreiben der Schrittimplementierung overriding-the-step-implementation

Jede Basis-Schritt-Komponente ermöglicht es den Entwicklern der Workflow-Modelle, die folgenden wichtigen Funktionen bei der Entwicklung zu konfigurieren:

Um die Komponente auf die Verwendung in einem bestimmten Workflow-Szenario zu fokussieren, konfigurieren Sie die Schlüsselfunktion im Design und entfernen Sie die Möglichkeit für Modellentwickler, sie zu ändern.

Hinzufügen von Formularen und Dialogfeldern zu Teilnehmer-Schritten adding-forms-and-dialogs-to-participant-steps

Passen Sie die Teilnehmer-Schritt-Komponente an, um Funktionen bereitzustellen, die sich in den Komponenten Formular „Teilnehmer-Schritt“ und Dialog „Teilnehmer-Schritt“ finden:

Führen Sie das folgende Verfahren auf der neuen Komponente durch (siehe Erstellen von benutzerdefinierten Workflow-Schritt-Komponenten):

Konfigurieren des Laufzeitverhaltens von Workflow-Schritten configuring-the-workflow-step-runtime-behavior

Fügen Sie unter dem Knoten cq:Component den Knoten cq:EditConfig hinzu. Fügen Sie darunter einen nt:unstructured-Knoten hinzu (er muss den Namen cq:formParameters aufweisen) und fügen Sie zu diesem Knoten die folgenden Eigenschaften hinzu:

Beständige Daten und Zugriff persisting-and-accessing-data

Beständige Daten für nachfolgende Workflow-Schritte persisting-data-for-subsequent-workflow-steps

Sie können Workflow-Metadaten verwenden, um Informationen beizubehalten, die während der Lebensdauer des Workflows - und zwischen Schritten - erforderlich sind. Eine gängige Anforderung an Workflow-Schritte besteht darin, Daten für die zukünftige Verwendung beizubehalten oder die beibehaltenen Daten aus vorherigen Schritten abzurufen.

Workflow-Metadaten werden in einem MetaDataMap-Objekt gespeichert. Die Java-API stellt die Methode Workflow.getWorkflowData bereit, die ein WorkflowData-Objekt zurückgibt, das das entsprechende MetaDataMap-Objekt bereitstellt. Dieses WorkflowData MetaDataMap-Objekt ist für den OSGi-Dienst oder das ECMA-Skript einer Schritt-Komponente verfügbar.

Java java

Die Ausführungsmethode der WorkflowProcess-Implementierung wird an das Objekt WorkItem weitergegeben. Mit diesem Objekt können Sie das WorkflowData-Objekt für die aktuelle Workflow-Instanz abrufen. Im folgenden Beispiel wird ein Element zum Workflow-Objekt MetaDataMap hinzugefügt und jedes Element protokolliert. Das Element ("mykey", "My Step Value") steht für nachfolgende Schritte im Workflow zur Verfügung.

public void execute(WorkItem item, WorkflowSession session, MetaDataMap args) throws WorkflowException {

    MetaDataMap wfd = item.getWorkflow().getWorkflowData().getMetaDataMap();

    wfd.put("mykey", "My Step Value");

    Set<String> keyset = wfd.keySet();
    Iterator<String> i = keyset.iterator();
    while (i.hasNext()){
     Object key = i.next();
     log.info("The workflow medata includes key {} and value {}",key.toString(),wfd.get(key).toString());
    }
}

ECMA-Skript ecma-script

Die Variable graniteWorkItem ist die ECMA-Skript-Repräsentation des aktuellen Java-Objekts WorkItem. Daher können Sie mit der Variablen graniteWorkItem die Workflow-Metadaten abrufen. Mit dem folgenden ECMA-Skript können Sie einen Prozess-Schritt implementieren, um ein Element zum Workflow-Objekt MetaDataMap hinzuzufügen und dann jedes Element zu protokollieren. Diese Elemente sind dann für nachfolgende Schritte im Workflow verfügbar.

var currentDateInMillis = new Date().getTime();

graniteWorkItem.getWorkflowData().getMetaDataMap().put("hardcodedKey","theKey");

graniteWorkItem.getWorkflowData().getMetaDataMap().put("currentDateInMillisKey",currentDateInMillis);

var iterator = graniteWorkItem.getWorkflowData().getMetaDataMap().keySet().iterator();
while (iterator.hasNext()){
    var key = iterator.next();
    log.info("Workflow metadata key, value = " + key.toString() + ", " + graniteWorkItem.getWorkflowData().getMetaDataMap().get(key));
}

Zugreifen auf Dialogfeldeigenschaftswerte zur Laufzeit accessing-dialog-property-values-at-runtime

Das Objekt MetaDataMap der Workflow-Instanzen ist nützlich, um Daten während des Workflow-Lebenszyklus zu speichern und abzurufen. Bei Implementierungen von Workflow-Schritt-Komponenten ist MetaDataMap besonders hilfreich, um Eigenschaftswerte der Komponenten zur Laufzeit abzurufen.

Der Workflow MetaDataMap ist für Java- und ECMA-Skript-Prozessimplementierungen verfügbar:

Beispiel: Abrufen der Argumente der Prozess-Schritt-Komponente example-retrieving-the-arguments-of-the-process-step-component

Das Dialogfeld „Bearbeiten“ der Komponente Process Step enthält die Eigenschaft Arguments. Der Wert der Eigenschaft Argumente wird in den Workflow-Metadaten gespeichert und mit dem Schlüssel PROCESS_ARGS verknüpft.

Im folgenden Diagramm hat die Eigenschaft Argumente den Wert argument1, argument2:

Java java-1

Der folgende Java-Code ist die execute-Methode für eine WorkflowProcess-Implementierung. Die Methode protokolliert den Wert in der args-MetaDataMap, die mit dem Schlüssel PROCESS_ARGS verknüpft ist.

public void execute(WorkItem item, WorkflowSession session, MetaDataMap args) throws WorkflowException {
     if (args.containsKey("PROCESS_ARGS")){
      log.info("workflow metadata for key PROCESS_ARGS and value {}",args.get("PROCESS_ARGS","string").toString());
     }
    }

Wenn ein Prozessschritt, der diese Java-Implementierung verwendet, ausgeführt wird, enthält das Protokoll den folgenden Eintrag:

16.02.2018 12:07:39.566 *INFO* [JobHandler: /var/workflow/instances/server0/2018-02-16/model_855140139900189:/content/we-retail/de] com.adobe.example.workflow.impl.process.LogArguments workflow metadata for key PROCESS_ARGS and value argument1, argument2

ECMA-Skript ecma-script-1

Das folgende ECMA-Skript wird als Prozess für die Prozessschritt. Es protokolliert die Anzahl der Argumente und die Argumentwerte:

var iterator = graniteWorkItem.getWorkflowData().getMetaDataMap().keySet().iterator();
while (iterator.hasNext()){
    var key = iterator.next();
    log.info("Workflow metadata key, value = " + key.toString() + ", " + graniteWorkItem.getWorkflowData().getMetaDataMap().get(key));
}
log.info("hardcodedKey "+ graniteWorkItem.getWorkflowData().getMetaDataMap().get("hardcodedKey"));
log.info("currentDateInMillisKey "+ graniteWorkItem.getWorkflowData().getMetaDataMap().get("currentDateInMillisKey"));

Skripte und Prozessargumente scripts-and-process-arguments

In einem Skript für eine Prozess-Schritt-Komponente sind die Argumente über das Objekt args verfügbar.

Beim Erstellen einer benutzerdefinierten Schritt-Komponente ist das Objekt metaData in einem Skript verfügbar. Dieses Objekt ist auf ein einziges String-Argument beschränkt.

Entwickeln von Implementierungen von Prozessschritten developing-process-step-implementations

Wenn Prozessschritte während des Prozesses gestartet werden, senden die Schritte eine Anfrage an einen OSGi-Dienst oder führen ein ECMA-Skript aus. Entwickeln Sie den Dienst oder das ECMA-Skript, das die für Ihren Workflow erforderlichen Aktionen ausführt.

Implementieren eines Prozessschritts mit einer Java-Klasse implementing-a-process-step-with-a-java-class

So definieren Sie einen Prozess-Schritt als OSGi-Dienstkomponente (Java-Paket):

Die Java-Methoden bzw. die Klassen, die die ausführbare Java-Methode implementieren, werden als OSGi-Dienste registriert, sodass Sie Methoden jederzeit während der Laufzeit hinzufügen können.

Die folgende OSGi-Komponente fügt die Eigenschaft approved zum Seiteninhaltsknoten hinzu, wenn die Payload eine Seite ist:

package com.adobe.example.workflow.impl.process;

import com.adobe.granite.workflow.WorkflowException;
import com.adobe.granite.workflow.WorkflowSession;
import com.adobe.granite.workflow.exec.WorkItem;
import com.adobe.granite.workflow.exec.WorkflowData;
import com.adobe.granite.workflow.exec.WorkflowProcess;
import com.adobe.granite.workflow.metadata.MetaDataMap;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Property;
import org.apache.felix.scr.annotations.Service;

import org.osgi.framework.Constants;

import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

/**
 * Sample workflow process that sets an <code>approve</code> property to the payload based on the process argument value.
 */
@Component
@Service
public class MyProcess implements WorkflowProcess {

 @Property(value = "An example workflow process implementation.")
 static final String DESCRIPTION = Constants.SERVICE_DESCRIPTION;
 @Property(value = "Adobe")
 static final String VENDOR = Constants.SERVICE_VENDOR;
 @Property(value = "My Sample Workflow Process")
 static final String LABEL="process.label";

 private static final String TYPE_JCR_PATH = "JCR_PATH";

 public void execute(WorkItem item, WorkflowSession session, MetaDataMap args) throws WorkflowException {
  WorkflowData workflowData = item.getWorkflowData();
  if (workflowData.getPayloadType().equals(TYPE_JCR_PATH)) {
   String path = workflowData.getPayload().toString() + "/jcr:content";
   try {
    Session jcrSession = session.adaptTo(Session.class);
    Node node = (Node) jcrSession.getItem(path);
    if (node != null) {
     node.setProperty("approved", readArgument(args));
     jcrSession.save();
    }
   } catch (RepositoryException e) {
    throw new WorkflowException(e.getMessage(), e);
   }
  }
 }

 private boolean readArgument(MetaDataMap args) {
  String argument = args.get("PROCESS_ARGS", "false");
  return argument.equalsIgnoreCase("true");
 }
}

Verwenden von ECMAScript using-ecmascript

ECMA-Skripte ermöglichen es Skriptentwicklern, Prozessschritte zu implementieren. Die Skripte befinden sich im JCR-Repository und werden von dort aus ausgeführt.

In der folgenden Tabelle sind die Variablen aufgeführt, die unmittelbar für Prozessskripte verfügbar sind und Zugriff auf Objekte der Workflow-Java-API bieten.

Das folgende Beispielskript zeigt den Zugriff auf den JCR-Knoten, der die Workflow-Payload repräsentiert. Die Variable graniteWorkflowSession ist an eine JCR-Sitzungsvariable angepasst, mit der der Knoten vom Payload-Pfad abgerufen wird.

var workflowData = graniteWorkItem.getWorkflowData();
if (workflowData.getPayloadType() == "JCR_PATH") {
    var path = workflowData.getPayload().toString();
    var jcrsession = graniteWorkflowSession.adaptTo(Packages.javax.jcr.Session);
    var node = jcrsession.getNode(path);
    if (node.hasProperty("approved")){
     node.setProperty("approved", args[0] == "true" ? true : false);
     node.save();
 }
}

Das folgende Skript prüft, ob es sich bei der Payload um ein Bild (.png-Datei) handelt, erstellt ein Schwarz-Weiß-Bild davon und speichert es als gleichrangingen Knoten.

var workflowData = graniteWorkItem.getWorkflowData();
if (workflowData.getPayloadType() == "JCR_PATH") {
    var path = workflowData.getPayload().toString();
    var jcrsession = graniteWorkflowSession.adaptTo(Packages.javax.jcr.Session);
    var node = jcrsession.getRootNode().getNode(path.substring(1));
     if (node.isNodeType("nt:file") && node.getProperty("jcr:content/jcr:mimeType").getString().indexOf("image/") == 0) {
        var is = node.getProperty("jcr:content/jcr:data").getStream();
        var layer = new Packages.com.day.image.Layer(is);
        layer.grayscale();
                var parent = node.getParent();
                var gn = parent.addNode("grey" + node.getName(), "nt:file");
        var content = gn.addNode("jcr:content", "nt:resource");
                content.setProperty("jcr:mimeType","image/png");
                var cal = Packages.java.util.Calendar.getInstance();
                content.setProperty("jcr:lastModified",cal);
                var f = Packages.java.io.File.createTempFile("test",".png");
        var tout = new Packages.java.io.FileOutputStream(f);
        layer.write("image/png", 1.0, tout);
        var fis = new Packages.java.io.FileInputStream(f);
                content.setProperty("jcr:data", fis);
                parent.save();
        tout.close();
        fis.close();
        is.close();
        f.deleteOnExit();
    }
}

So verwenden Sie das Skript:

Entwickeln von Teilnehmerauswahl developing-participant-choosers

Sie können Teilnehmerentscheidungen für Dynamischer Teilnehmer - Schritt Komponenten.

Wenn eine Dynamischer-Teilnehmer-Schritt-Komponente während eines Workflows gestartet wird, muss der Schritt feststellen, welchem Teilnehmer das erzeugte Arbeitselement zugewiesen werden kann. Dazu geht der Schritt auf eine der folgenden Weisen vor:

Sie können einen Dienst oder ein ECMA-Skript entwickeln, das den Teilnehmer entsprechend den Anforderungen Ihres Workflows auswählt.

Entwickeln einer Teilnehmerauswahl mit einer Java-Klasse developing-a-participant-chooser-using-a-java-class

So definieren Sie einen Teilnehmerschritt als OSGi-Dienstkomponente (Java-Klasse):

Entwickeln einer Teilnehmerauswahl mit einem ECMA-Skript developing-a-participant-chooser-using-an-ecma-script

Sie können ein ECMA-Skript erstellen, das den Benutzer auswählt, dem das Arbeitselement zugewiesen ist, dem die Teilnehmer-Schritt generiert. Das Skript muss eine Funktion namens getParticipant enthalten, das keine Argumente benötigt und einen String zurückgibt, der die ID eines Benutzers oder einer Gruppe enthält.

Skripte befinden sich im JCR-Repository und werden von dort aus ausgeführt.

In der folgenden Tabelle sind die Variablen aufgeführt, die sofortigen Zugriff auf Workflow-Java-Objekte in Ihren Skripten bieten.

function getParticipant() {
    var workflowData = graniteWorkItem.getWorkflowData();
    if (workflowData.getPayloadType() == "JCR_PATH") {
        var path = workflowData.getPayload().toString();
        if (path.indexOf("/content/we-retail/de") == 0) {
            return "admin";
        } else {
            return "administrators";
        }
    }
}

Handhabung von Workflow-Paketen handling-workflow-packages

Workflow-Pakete kann zur Verarbeitung an einen Workflow übergeben werden. Workflow-Pakete enthalten Verweise auf Ressourcen wie Seiten und Assets.

Sie können Workflow-Schritte entwickeln, die die Paketressourcen abrufen und verarbeiten. Die folgenden Elemente des Pakets com.day.cq.workflow.collection bieten Zugriff auf Workflow-Pakete:

Die folgende Java-Beispielklasse zeigt, wie Paketressourcen abgerufen werden:

package com.adobe.example;

import java.util.ArrayList;
import java.util.List;

import com.day.cq.workflow.WorkflowException;
import com.day.cq.workflow.WorkflowSession;
import com.day.cq.workflow.collection.ResourceCollection;
import com.day.cq.workflow.collection.ResourceCollectionManager;
import com.day.cq.workflow.collection.ResourceCollectionUtil;
import com.day.cq.workflow.exec.WorkItem;
import com.day.cq.workflow.exec.WorkflowData;
import com.day.cq.workflow.exec.WorkflowProcess;
import com.day.cq.workflow.metadata.MetaDataMap;

import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Property;
import org.apache.felix.scr.annotations.Service;
import org.apache.felix.scr.annotations.Reference;
import org.osgi.framework.Constants;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.jcr.Node;
import javax.jcr.PathNotFoundException;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

@Component
@Service
public class LaunchBulkActivate implements WorkflowProcess {

 private static final Logger log = LoggerFactory.getLogger(LaunchBulkActivate.class);

 @Property(value="Bulk Activate for Launches")
  static final String PROCESS_NAME ="process.label";
 @Property(value="A sample workflow process step to support Launches bulk activation of pages")
 static final String SERVICE_DESCRIPTION = Constants.SERVICE_DESCRIPTION;

 @Reference
 private ResourceCollectionManager rcManager;
public void execute(WorkItem workItem, WorkflowSession workflowSession) throws Exception {
    Session session = workflowSession.getSession();
    WorkflowData data = workItem.getWorkflowData();
    String path = null;
    String type = data.getPayloadType();
    if (type.equals(TYPE_JCR_PATH) && data.getPayload() != null) {
        String payloadData = (String) data.getPayload();
        if (session.itemExists(payloadData)) {
            path = payloadData;
        }
    } else if (data.getPayload() != null && type.equals(TYPE_JCR_UUID)) {
        Node node = session.getNodeByUUID((String) data.getPayload());
        path = node.getPath();
    }

    // CUSTOMIZED CODE IF REQUIRED....

    if (path != null) {
        // check for resource collection
        ResourceCollection rcCollection = ResourceCollectionUtil.getResourceCollection((Node)session.getItem(path), rcManager);
        // get list of paths to replicate (no resource collection: size == 1
        // otherwise size >= 1
        List<String> paths = getPaths(path, rcCollection);
        for (String aPath: paths) {

            // CUSTOMIZED CODE....

        }
    } else {
        log.warn("Cannot process because path is null for this " + "workitem: " + workItem.toString());
    }
}

/**
 * helper
 */
private List<String> getPaths(String path, ResourceCollection rcCollection) {
    List<String> paths = new ArrayList<String>();
    if (rcCollection == null) {
        paths.add(path);
    } else {
        log.debug("ResourceCollection detected " + rcCollection.getPath());
        // this is a resource collection. the collection itself is not
        // replicated. only its members
        try {
            List<Node> members = rcCollection.list(new String[]{"cq:Page", "dam:Asset"});
            for (Node member: members) {
                String mPath = member.getPath();
                paths.add(mPath);
            }
        } catch(RepositoryException re) {
            log.error("Cannot build path list out of the resource collection " + rcCollection.getPath());
        }
    }
    return paths;
}
}

Beispiel: Erstellen eines benutzerspezifischen Schritts example-creating-a-custom-step

Eine einfache Möglichkeit, mit der Erstellung Ihres eigenen benutzerdefinierten Schritts zu beginnen, besteht darin, einen vorhandenen Schritt aus folgenden Quellen zu kopieren:

/libs/cq/workflow/components/model

Erstellen des grundlegenden Schritts creating-the-basic-step

Definieren des Dialogfelds "Schritt konfigurieren" defining-the-step-configure-dialog

Nachher Erstellen des grundlegenden Schritts, definieren Sie den Schritt . Konfigurieren Dialogfeld wie folgt:

In diesem Beispiel verwendetes Beispiel-Markup sample-markup-used-in-this-example

Das Markup für einen benutzerdefinierten Schritt findet sich in der Datei .content.xml des Stammknotens der Komponente. Die in diesem Beispiel verwendete Datei .content.xml:

/apps/cq/workflow/components/model/myCustomStep/.content.xml

<?xml version="1.0" encoding="UTF-8"?>
<jcr:root xmlns:sling="https://sling.apache.org/jcr/sling/1.0" xmlns:cq="https://www.day.com/jcr/cq/1.0" xmlns:jcr="https://www.jcp.org/jcr/1.0"
    cq:icon="bell"
    jcr:primaryType="cq:Component"
    jcr:title="My Custom Step"
    sling:resourceSuperType="cq/workflow/components/model/process"
    allowedParents="[*/parsys]"
    componentGroup="Workflow"/>

Die in diesem Beispiel verwendete Datei _cq_editConfig.xml:

<?xml version="1.0" encoding="UTF-8"?>
<jcr:root xmlns:cq="https://www.day.com/jcr/cq/1.0" xmlns:jcr="https://www.jcp.org/jcr/1.0" xmlns:nt="https://www.jcp.org/jcr/nt/1.0"
    cq:disableTargeting="{Boolean}true"
    cq:inherit="{Boolean}true"
    jcr:primaryType="cq:EditConfig">
    <cq:formParameters
        jcr:primaryType="nt:unstructured"
        jcr:title="My Custom Step Card"
        SAMPLE_PROPERY="sample value"/>
    <cq:listeners
        jcr:primaryType="cq:EditListenersConfig"
        afterdelete="CQ.workflow.flow.Step.afterDelete"
        afteredit="CQ.workflow.flow.Step.afterEdit"
        afterinsert="CQ.workflow.flow.Step.afterInsert"
        afterMove="REFRESH_PAGE"/>
</jcr:root>

Die in diesem Beispiel verwendete Datei _cq_dialog/.content.xml:

<?xml version="1.0" encoding="UTF-8"?>
<jcr:root xmlns:sling="https://sling.apache.org/jcr/sling/1.0" xmlns:cq="https://www.day.com/jcr/cq/1.0" xmlns:jcr="https://www.jcp.org/jcr/1.0" xmlns:nt="https://www.jcp.org/jcr/nt/1.0"
    jcr:primaryType="nt:unstructured"
    jcr:title="My Custom - Step Properties"
    sling:resourceType="cq/gui/components/authoring/dialog">
    <content
        jcr:primaryType="nt:unstructured"
        sling:resourceType="granite/ui/components/coral/foundation/tabs">
        <items jcr:primaryType="nt:unstructured">
            <common
                cq:hideOnEdit="true"
                jcr:primaryType="nt:unstructured"
                jcr:title="Common"
                sling:resourceType="granite/ui/components/coral/foundation/fixedcolumns"/>
            <process
                cq:hideOnEdit="true"
                jcr:primaryType="nt:unstructured"
                jcr:title="Process"
                sling:resourceType="granite/ui/components/coral/foundation/fixedcolumns"/>
            <mycommon
                jcr:primaryType="nt:unstructured"
                jcr:title="Common"
                sling:resourceType="granite/ui/components/coral/foundation/fixedcolumns">
                <items jcr:primaryType="nt:unstructured">
                    <columns
                        jcr:primaryType="nt:unstructured"
                        sling:resourceType="granite/ui/components/coral/foundation/container">
                        <items jcr:primaryType="nt:unstructured">
                            <title
                                jcr:primaryType="nt:unstructured"
                                sling:resourceType="granite/ui/components/coral/foundation/form/textfield"
                                fieldLabel="Title"
                                name="./jcr:title"/>
                            <description
                                jcr:primaryType="nt:unstructured"
                                sling:resourceType="granite/ui/components/coral/foundation/form/textarea"
                                fieldLabel="Description"
                                name="./jcr:description"/>
                        </items>
                    </columns>
                </items>
            </mycommon>
            <advanced
                jcr:primaryType="nt:unstructured"
                jcr:title="Advanced"
                sling:resourceType="granite/ui/components/coral/foundation/fixedcolumns">
                <items jcr:primaryType="nt:unstructured">
                    <columns
                        jcr:primaryType="nt:unstructured"
                        sling:resourceType="granite/ui/components/coral/foundation/container">
                        <items jcr:primaryType="nt:unstructured">
                            <email
                                jcr:primaryType="nt:unstructured"
                                sling:resourceType="granite/ui/components/coral/foundation/form/checkbox"
                                fieldDescription="Notify user via email."
                                fieldLabel="Email"
                                name="./metaData/PROCESS_AUTO_ADVANCE"
                                text="Notify user via email."
                                value="true"/>
                        </items>
                    </columns>
                </items>
            </advanced>
        </items>
    </content>
</jcr:root>