Utöka arbetsflödesfunktioner extending-workflow-functionality

I det här avsnittet beskrivs hur du utvecklar anpassade stegkomponenter för dina arbetsflöden och hur du interagerar programmatiskt med arbetsflöden.

När du skapar ett anpassat arbetsflödessteg ingår följande aktiviteter:

Du kan även interagera med dina arbetsflöden från program och skript.

Steg-komponenter för arbetsflöde - Grunderna workflow-step-components-the-basics

En arbetsflödesstegkomponent definierar utseendet och beteendet för steget när du skapar arbetsflödesmodeller:

Precis som med alla komponenter ärver arbetsflödesstegkomponenter från den komponent som har angetts för egenskapen sling:resourceSuperType. I följande diagram visas hierarkin för cq:component noder som utgör grunden för alla komponenter för arbetsflödessteg. Diagrammet innehåller också komponenterna Processsteg, Deltagarsteg och Dynamiskt deltagarsteg eftersom dessa är de vanligaste (och vanligaste) startpunkterna för utveckling av anpassade stegkomponenter.

Komponenten /libs/cq/workflow/components/model/step är den närmaste gemensamma överordnade för Processsteg, Deltagarsteg och Dynamiskt deltagarsteg som alla ärver följande objekt:

ECMA-skript ecma-scripts

Följande objekt är tillgängliga (beroende på stegtyp) i ECMA-skript:

MetaDataMaps metadatamaps

Du kan använda arbetsflödets metadata för att behålla information som krävs under arbetsflödets livstid. Ett vanligt krav för arbetsflödessteg är att behålla data för framtida användning i arbetsflödet eller att hämta beständiga data.

Det finns tre typer av MetaDataMap-objekt - för Workflow-, WorkflowData- och WorkItem-objekt. De har alla samma syfte - att lagra metadata.

En WorkItem har en egen MetaDataMap som bara kan användas medan arbetsobjektet (till exempel steg) körs.

Både Workflow och WorkflowData metadatamappningar delas över hela arbetsflödet. I dessa fall bör du bara använda metadatamappningen WorkflowData.

Skapa anpassade komponenter för arbetsflödessteg creating-custom-workflow-step-components

Arbetsflödesstegkomponenter kan skapas på samma sätt som andra komponenter.

Om du vill ärva från en av de (befintliga) basstegskomponenterna lägger du till följande egenskap i noden cq:Component:

Ange standardtitel och beskrivning för stegförekomster specifying-the-default-title-and-description-for-step-instances

Använd följande procedur för att ange standardvärden för fälten Rubrik och Beskrivning på fliken Allmänt.

Spara egenskapsvärden i arbetsflödesmetadata saving-property-values-in-workflow-metadata

Egenskapen name för cq:Widget objekt anger den JCR-nod som lagrar widgetens värde. När widgetar i dialogrutan för arbetsflödesstegkomponenter lagrar värden under noden ./metaData läggs värdet till i arbetsflödet MetaDataMap.

Ett textfält i en dialogruta är till exempel en cq:Widget-nod som har följande egenskaper:

Värdet som anges i det här textfältet läggs till i arbetsflödesinstansens [MetaDataMap](#metadatamaps)-objekt och är associerat med subject-tangenten.

Åsidosätta stegimplementeringen overriding-the-step-implementation

Med varje basstegskomponent kan utvecklare av arbetsflödesmodeller konfigurera följande nyckelfunktioner i designläge:

Om du vill fokusera komponenten för användning i ett specifikt arbetsflödesscenario konfigurerar du nyckelfunktionen i designen och tar bort möjligheten för modellutvecklare att ändra den.

Lägga till Forms och dialogrutor i deltagarsteg adding-forms-and-dialogs-to-participant-steps

Anpassa stegkomponenten för deltagare för att tillhandahålla funktioner som finns i komponenterna Formulärdeltagare, steg och Dialogrutedeltagare, steg:

Utför följande procedur på den nya komponenten (se Skapa anpassade stegkomponenter för arbetsflöde):

Konfigurera beteende för arbetsflödesstegets körningsmiljö configuring-the-workflow-step-runtime-behavior

Lägg till en cq:EditConfig-nod nedanför noden cq:Component. Under den här noden lägger du till en nt:unstructured-nod (måste heta cq:formParameters) och lägger till följande egenskaper:

Bevara och få åtkomst till data persisting-and-accessing-data

Beständiga data för efterföljande arbetsflödessteg persisting-data-for-subsequent-workflow-steps

Du kan använda arbetsflödets metadata för att behålla information som krävs under arbetsflödets livstid - och mellan steg. Ett vanligt krav för arbetsflödessteg är att bevara data för framtida bruk eller att hämta beständiga data från tidigare steg.

Arbetsflödets metadata lagras i ett MetaDataMap-objekt. Java-API:t tillhandahåller metoden Workflow.getWorkflowData för att returnera ett WorkflowData -objekt som innehåller rätt MetaDataMap-objekt. Det här WorkflowData MetaDataMap-objektet är tillgängligt för OSGi-tjänsten eller ECMA-skriptet för en stegkomponent.

Java java

Körningsmetoden för implementeringen av WorkflowProcess skickas till objektet WorkItem. Använd det här objektet för att hämta WorkflowData-objektet för den aktuella arbetsflödesinstansen. I följande exempel läggs ett objekt till i arbetsflödesobjektet MetaDataMap och sedan loggas varje objekt. Objektet ("minkey","My Step Value") är tillgängligt för efterföljande steg i arbetsflödet.

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

Variabeln graniteWorkItem är ECMA-skriptrepresentationen av det aktuella WorkItem Java-objektet. Du kan därför använda variabeln graniteWorkItem för att hämta arbetsflödets metadata. Följande ECMA-skript kan användas för att implementera ett Processsteg för att lägga till ett objekt i arbetsflödesobjektet MetaDataMap och sedan logga varje objekt. Dessa objekt är sedan tillgängliga för efterföljande steg i arbetsflödet.

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));
}

Åtkomst till egenskapsvärden för dialogrutor vid körning accessing-dialog-property-values-at-runtime

Objektet MetaDataMap i arbetsflödesinstanser är användbart för att lagra och hämta data under arbetsflödets hela livstid. För implementeringar av komponenter för arbetsflödessteg är MetaDataMap särskilt användbart för att hämta egenskapsvärden för komponenter vid körning.

Arbetsflödet MetaDataMap är tillgängligt för implementeringar av Java- och ECMA-skriptprocessen:

Exempel: Hämta argument för komponenten Processsteg example-retrieving-the-arguments-of-the-process-step-component

Redigeringsdialogrutan för komponenten Processsteg innehåller egenskapen Arguments . Värdet för egenskapen Arguments lagras i arbetsflödets metadata och associeras med nyckeln PROCESS_ARGS.

I följande diagram är värdet för egenskapen Arguments argument1, argument2:

Java java-1

Följande Java-kod är metoden execute för en WorkflowProcess-implementering. Metoden loggar värdet i args MetaDataMap som är associerad med nyckeln PROCESS_ARGS.

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());
     }
    }

När ett processsteg som använder den här Java-implementeringen körs innehåller loggen följande post:

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

Följande ECMA-skript används som process för Processsteg. Här loggas antalet argument och argumentvärdena:

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"));

Skript och processargument scripts-and-process-arguments

I ett skript för en Process Step-komponent är argument tillgängliga via objektet args.

När du skapar en anpassad stegkomponent är objektet metaData tillgängligt i ett skript. Det här objektet är begränsat till ett strängargument.

Utveckla stegimplementeringar för processer developing-process-step-implementations

När processteg startas under en arbetsflödesprocess skickar stegen en begäran till en OSGi-tjänst eller kör ett ECMA-skript. Utveckla den tjänst eller det ECMA-skript som utför de åtgärder som arbetsflödet kräver.

Implementera ett processsteg med en Java-klass implementing-a-process-step-with-a-java-class

Så här definierar du ett processteg som en OSGI-tjänstkomponent (Java bundle):

Java-metoderna, respektive klasserna som implementerar den körbara Java-metoden, registreras som OSGI-tjänster, vilket gör att du kan lägga till metoder när som helst under körningen.

Följande OSGI-komponent lägger till egenskapen approved i sidinnehållsnoden när nyttolasten är en sida:

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");
 }
}

Använda ECMAScript using-ecmascript

Med ECMA-skript kan skriptutvecklare implementera processsteg. Skripten finns i JCR-databasen och körs därifrån.

I följande tabell visas de variabler som är omedelbart tillgängliga för att bearbeta skript, vilket ger tillgång till objekt i arbetsflödets Java API.

Följande exempelskript visar hur du får åtkomst till JCR-noden som representerar arbetsflödets nyttolast. Variabeln graniteWorkflowSession är anpassad till en JCR-sessionsvariabel, som används för att hämta noden från nyttolastsökvägen.

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();
 }
}

Följande skript kontrollerar om nyttolasten är en bild ( .png fil), skapar en svartvit bild från den och sparar den som en nod på samma nivå.

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();
    }
}

Så här använder du skriptet:

Utveckla deltagarväljare developing-participant-choosers

Du kan utveckla deltagarval för komponenter för dynamiskt deltagarsteg.

När en komponent för dynamisk deltagare startas under ett arbetsflöde, måste steget definiera deltagaren som det genererade arbetsobjektet kan tilldelas till. Så här gör du i det här steget:

Du kan utveckla en tjänst eller ett ECMA-skript som väljer deltagare enligt kraven i ditt arbetsflöde.

Utveckla en deltagarväljare Använda en Java-klass developing-a-participant-chooser-using-a-java-class

Så här definierar du ett deltagarsteg som en OSGI-tjänstkomponent (Java-klass):

Utveckla en deltagarväljare med ett ECMA-skript developing-a-participant-chooser-using-an-ecma-script

Du kan skapa ett ECMA-skript som väljer användaren som är tilldelad arbetsposten som genereras av Deltagarsteget. Skriptet måste innehålla en funktion med namnet getParticipant som inte kräver några argument, och returnerar en String som innehåller ID:t för en användare eller grupp.

Skript finns i JCR-databasen och körs därifrån.

I följande tabell visas de variabler som ger omedelbar åtkomst till Java-objekt i arbetsflöden i dina skript.

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";
        }
    }
}

Hantera arbetsflödespaket handling-workflow-packages

Arbetsflödespaket kan skickas till ett arbetsflöde för bearbetning. Arbetsflödespaket innehåller referenser till resurser som sidor och resurser.

Du kan utveckla arbetsflödessteg som hämtar paketresurserna och bearbetar dem. Följande medlemmar i paketet com.day.cq.workflow.collection ger åtkomst till arbetsflödespaket:

I följande exempel visas hur Java-klassen hämtar paketresurser:

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;
}
}

Exempel: Skapa ett anpassat steg example-creating-a-custom-step

Ett enkelt sätt att börja skapa egna anpassade steg är att kopiera ett befintligt steg från:

/libs/cq/workflow/components/model

Skapa det grundläggande steget creating-the-basic-step

Definiera dialogrutan Konfigurera steg defining-the-step-configure-dialog

När du har skapat det grundläggande steget definierar du dialogrutan Konfigurera enligt följande:

Exempelkod som används i det här exemplet sample-markup-used-in-this-example

Markering för ett anpassat steg representeras i .content.xml för komponentens rotnod. Exemplet .content.xml som används i det här exemplet:

/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"/>

_cq_editConfig.xml-exemplet som används i det här exemplet:

<?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>

_cq_dialog/.content.xml-exemplet som används i det här exemplet:

<?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>