Uitbreiding van workflowfunctionaliteit extending-workflow-functionality

Dit onderwerp beschrijft hoe te om de componenten van de douanestap voor uw werkschema's te ontwikkelen, toen hoe te programmatically met werkschema's in wisselwerking te staan.

Het maken van een aangepaste workflowstap omvat de volgende activiteiten:

U kunt ook communiceren met uw workflows vanuit uw programma's en scripts.

Workflowstapcomponenten - De basisbeginselen workflow-step-components-the-basics

Een workflowcomponent definieert de vormgeving en het gedrag van de stap bij het maken van workflowmodellen:

Zoals met alle componenten, workflowstapcomponenten overerven van de component die is opgegeven voor de component sling:resourceSuperType eigenschap. Het volgende diagram toont de hiërarchie van cq:component knooppunten die de basis vormen van alle workflowstapcomponenten. Het diagram bevat ook de Processtap, Stap deelnemer, en Stap dynamische deelnemer componenten, aangezien dit de gemeenschappelijkste (en fundamentele) uitgangspunt voor het ontwikkelen van de componenten van de douanestappen zijn.

De /libs/cq/workflow/components/model/step component is de dichtstbijzijnde gangbare voorouder van de Processtap, Stap deelnemer, en Stap dynamische deelnemer, die alle de volgende items overerven:

ECMA-scripts ecma-scripts

De volgende objecten zijn beschikbaar (afhankelijk van het type stap) in ECMA-scripts:

MetaDataMaps metadatamaps

U kunt metagegevens over workflows gebruiken om de informatie die tijdens de levensduur van de workflow vereist is, voort te zetten. Een algemene vereiste voor workflowstappen is dat gegevens voor toekomstig gebruik in de workflow moeten worden behouden of dat de blijvend opgeslagen gegevens moeten worden opgehaald.

Er zijn drie typen objecten MetaDataMap - voor Workflow, WorkflowData en WorkItem objecten. Ze hebben allemaal hetzelfde doel: metagegevens opslaan.

Een WorkItem heeft zijn eigen MetaDataMap die slechts kan worden gebruikt terwijl dat werkpunt (b.v. stap) loopt.

Beide Workflow en WorkflowData metadatamaps worden over de gehele werkstroom gedeeld. In deze gevallen wordt het aanbevolen alleen de WorkflowData metagegevensoverzicht.

Aangepaste workflowonderdelen maken creating-custom-workflow-step-components

Workflowstapcomponenten kunnen gemaakt op dezelfde manier als een andere component.

Om van één van de (bestaande) componenten van de basisstap over te erven, voeg het volgende bezit aan toe cq:Component knooppunt:

De standaardtitel en -beschrijving opgeven voor instanties Step specifying-the-default-title-and-description-for-step-instances

Gebruik de volgende procedure om standaardwaarden op te geven voor de Titel en Beschrijving velden op de Vaak tab.

Eigenschapwaarden opslaan in werkstroommetagegevens saving-property-values-in-workflow-metadata

De eigenschap name van cq:Widget Hiermee wordt het JCR-knooppunt opgegeven dat de waarde van de widget opslaat. Wanneer widgets in het dialoogvenster met workflowstapcomponenten waarden opslaan onder de ./metaData node, de waarde wordt toegevoegd aan de workflow MetaDataMap.

Een tekstveld in een dialoogvenster is bijvoorbeeld een cq:Widget knooppunt met de volgende eigenschappen:

De waarde die in dit tekstveld wordt opgegeven, wordt toegevoegd aan de instantie van de werkstroom [MetaDataMap](#metadatamaps) en is gekoppeld aan de subject toets.

De stapimplementatie overschrijven overriding-the-step-implementation

Elke component van de basisstap laat de ontwikkelaars van het werkschemamodel toe om de volgende zeer belangrijke eigenschappen in ontwerptijd te vormen:

Om de component voor gebruik in een specifiek werkschemascenario te concentreren, vorm de belangrijkste eigenschap in het ontwerp en verwijder de capaciteit voor modelontwikkelaars om het te veranderen.

Forms en dialoogvensters toevoegen aan stappen van deelnemers adding-forms-and-dialogs-to-participant-steps

Pas uw component van de deelnemersstap aan om eigenschappen te verstrekken die in worden gevonden Stap voor deelnemer aan formulier en Stap deelnemer van dialoogvenster componenten:

Voer de volgende procedure op uw nieuwe component uit (zie Aangepaste workflowonderdelen maken):

Werking voor Workflowstap configureren configuring-the-workflow-step-runtime-behavior

Onder de cq:Component knooppunt, toevoegen cq:EditConfig knooppunt. Hieronder wordt een nt:unstructured node (moet een naam hebben cq:formParameters) en aan dat knooppunt de volgende eigenschappen toevoegen:

Gegevens behouden en openen persisting-and-accessing-data

Gegevens behouden voor volgende workflowstappen persisting-data-for-subsequent-workflow-steps

U kunt werkschemagegevens gebruiken om informatie voort te zetten die tijdens het leven van het werkschema - en tussen stappen wordt vereist. Een algemene vereiste voor workflowstappen is dat gegevens voor toekomstig gebruik behouden blijven of dat de blijvend gegevens uit eerdere stappen worden opgehaald.

De metagegevens van de workflow worden opgeslagen in een MetaDataMap object. De Java API biedt de Workflow.getWorkflowData methode om een WorkflowData object dat het juiste MetaDataMap object. Dit WorkflowData MetaDataMap -object beschikbaar is voor de OSGi-service of het ECMA-script van een step-component.

Java java

De methode voor het uitvoeren van de opdracht WorkflowProcess de uitvoering wordt goedgekeurd WorkItem object. Gebruik dit object om de WorkflowData object voor de huidige werkstroominstantie. In het volgende voorbeeld wordt een item aan de workflow toegevoegd MetaDataMap object en logt elk item vervolgens in. Het item ("mijnsleutel", "Mijn stapwaarde") is beschikbaar voor volgende stappen in de workflow.

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-script ecma-script

De graniteWorkItem variable is the ECMA script representation of the current WorkItem Java-object. Daarom kunt u graniteWorkItem variabele voor het verkrijgen van de metagegevens van de workflow. Het volgende ECMA-script kan worden gebruikt om een Processtap om een item aan de workflow toe te voegen MetaDataMap en registreer elk item vervolgens. Deze items zijn vervolgens beschikbaar voor volgende stappen in de workflow.

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

Dialoogvenstereigenschapswaarden openen bij uitvoering accessing-dialog-property-values-at-runtime

De MetaDataMap Het object met workflowinstanties is handig voor het opslaan en ophalen van gegevens gedurende de gehele levensduur van de workflow. Voor de implementatie van workflowcomponenten, MetaDataMap is vooral nuttig om componentenbezitswaarden bij runtime terug te winnen.

De workflow MetaDataMap is beschikbaar voor Java- en ECMA-scriptprocesimplementaties:

Voorbeeld: De argumenten van de processtapcomponent ophalen example-retrieving-the-arguments-of-the-process-step-component

Het dialoogvenster Bewerken van het dialoogvenster Processtap bevat de Argumenten eigenschap. De waarde van de Argumenten eigenschap wordt opgeslagen in de metagegevens van de workflow en is gekoppeld aan de eigenschap PROCESS_ARGS toets.

In het volgende diagram wordt de waarde van de Argumenten eigenschap is argument1, argument2:

Java java-1

De volgende Java-code is de execute methode voor een WorkflowProcess uitvoering. De methode registreert de waarde in de args MetaDataMap die verband houdt met de PROCESS_ARGS toets.

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

Wanneer een processtap wordt uitgevoerd die deze Java-implementatie gebruikt, bevat het logbestand de volgende vermelding:

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-script ecma-script-1

Het volgende ECMA-script wordt gebruikt als het proces voor het Processtap. Het registreert het aantal argumenten en de argumentwaarden:

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

Scripts en procesargumenten scripts-and-process-arguments

Binnen een script voor een Processtap component, argumenten zijn beschikbaar via args object.

Wanneer u een component met een aangepaste stap maakt, metaData is beschikbaar in een script. Dit object is beperkt tot één tekenreeksargument.

Implementaties van processtappen ontwikkelen developing-process-step-implementations

Wanneer de processtappen tijdens het proces van een werkschema zijn begonnen, verzenden de stappen een verzoek naar een dienst OSGi of voeren een manuscript ECMA uit. Ontwikkel de dienst of het manuscript ECMA dat de acties uitvoert die uw werkschema vereist.

Een processtap implementeren met een Java-klasse implementing-a-process-step-with-a-java-class

Een processtap definiëren als een OSGI-servicecomponent (Java-bundel):

De methoden java, respectievelijk de klassen die de uitvoerbare Java-methode implementeren, worden geregistreerd als OSGI-services, waarmee u tijdens runtime op elk moment methoden kunt toevoegen.

De volgende component OSGI voegt de eigenschap toe approved naar het knooppunt met pagina-inhoud wanneer de laadbewerking een pagina is:

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

ECMAScript gebruiken using-ecmascript

Met ECMA-scripts kunnen scriptontwikkelaars processtappen implementeren. De scripts bevinden zich in de JCR-opslagplaats en worden daar uitgevoerd.

In de volgende tabel staan de variabelen die direct beschikbaar zijn voor het verwerken van scripts, waarmee toegang wordt verleend tot objecten van de Java API voor de workflow.

Het volgende voorbeeldscript laat zien hoe u toegang krijgt tot het JCR-knooppunt dat de payload van de workflow vertegenwoordigt. De graniteWorkflowSession De variabele wordt aangepast aan een JCR-sessievariabele, die wordt gebruikt om het knooppunt op te halen uit het payload-pad.

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

Het volgende script controleert of de lading een afbeelding is ( .png ), maakt u er een zwart-witafbeelding van en slaat u deze op als een knooppunt op hetzelfde niveau.

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

Het script gebruiken:

Deelnemerkiezers ontwikkelen developing-participant-choosers

U kunt deelnemerskiezers ontwikkelen voor Stap dynamische deelnemer componenten.

Wanneer een Stap dynamische deelnemer is gestart tijdens een werkstroom, moet de stap bepalen aan welke deelnemer het gegenereerde werkitem kan worden toegewezen. Hiervoor moet u een van de volgende stappen uitvoeren:

U kunt de dienst of een manuscript ontwikkelen ECMA dat de deelnemer volgens de vereisten van uw werkschema selecteert.

Een kiezer voor deelnemers ontwikkelen met een Java-klasse developing-a-participant-chooser-using-a-java-class

Een deelnemersstap definiëren als een OSGI-servicecomponent (Java-klasse):

Een kiezer voor deelnemers ontwikkelen met behulp van een ECMA-script developing-a-participant-chooser-using-an-ecma-script

U kunt een manuscript tot stand brengen ECMA dat de gebruiker selecteert die het het werkpunt wordt toegewezen dat Stap deelnemer wordt gegenereerd. Het script moet een functie met de naam getParticipant dat vereist geen argumenten en retourneert een String die de id van een gebruiker of groep bevat.

Scripts bevinden zich in de JCR-opslagplaats en worden daar uitgevoerd.

De volgende tabel bevat een lijst met variabelen die directe toegang bieden tot Java-workflowobjecten in uw scripts.

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

Workflowpakketten verwerken handling-workflow-packages

Workflowpakketten kan worden doorgegeven aan een workflow voor verwerking. Workflowpakketten bevatten verwijzingen naar bronnen zoals pagina's en elementen.

U kunt workflowstappen ontwikkelen om de pakketbronnen te verkrijgen en deze te verwerken. De volgende leden van de com.day.cq.workflow.collection bieden toegang tot workflowpakketten:

In het volgende voorbeeld van de Java-klasse ziet u hoe u pakketbronnen kunt verkrijgen:

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

Voorbeeld: Een aangepaste stap maken example-creating-a-custom-step

Een gemakkelijke manier om uw eigen douanestap te beginnen te creëren is een bestaande stap van te kopiëren:

/libs/cq/workflow/components/model

De basisstap maken creating-the-basic-step

Het bepalen van Stap vormt Dialoogvenster defining-the-step-configure-dialog

Na De basisstap maken, definieert u de stap Configureren als volgt:

Sampleopmaak die in dit voorbeeld wordt gebruikt sample-markup-used-in-this-example

Opmaak voor een aangepaste stap wordt weergegeven in het dialoogvenster .content.xml van het basisknooppunt van de component. Het voorbeeld .content.xml gebruikt voor dit voorbeeld:

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

De _cq_editConfig.xml in dit voorbeeld gebruikt voorbeeld:

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

De _cq_dialog/.content.xml in dit voorbeeld gebruikt voorbeeld:

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