Show Menu
TEMAS×

Interactuar con flujos de trabajo mediante programación

Al personalizar y ampliar los flujos de trabajo , puede acceder a los objetos de flujo de trabajo:

Uso de la API de Java de workflow

La API de Java de flujo de trabajo consiste en el com.adobe.granite.workflow paquete y varios subpaquetes. El miembro más significativo de la API es la com.adobe.granite.workflow.WorkflowSession clase. La WorkflowSession clase proporciona acceso a objetos de flujo de trabajo de tiempo de diseño y tiempo de ejecución:
  • modelos de flujo de trabajo
  • elementos de trabajo
  • instancias de flujo de trabajo
  • datos de flujo de trabajo
  • elementos de bandeja de entrada
La clase también proporciona varios métodos para intervenir en los ciclos de vida del flujo de trabajo.
La siguiente tabla proporciona vínculos a la documentación de referencia de varios objetos Java clave que se utilizarán al interactuar programáticamente con flujos de trabajo. Los siguientes ejemplos muestran cómo obtener y utilizar los objetos de clase en el código.
Características
Objetos
Acceso a un flujo de trabajo
Ejecución y consulta de una instancia de flujo de trabajo
Administración de un modelo de flujo de trabajo
Información de un nodo que está en el flujo de trabajo (o no)

Obtención de objetos de flujo de trabajo en secuencias de comandos de ECMA

Como se describe en Localización de secuencias de comandos , AEM (mediante Apache Sling) proporciona un motor de secuencias de comandos ECMA que ejecuta secuencias de comandos ECMA del lado del servidor. La org.apache.sling.scripting.core.ScriptHelper clase está disponible inmediatamente para las secuencias de comandos como la sling variable.
La ScriptHelper clase proporciona acceso al objeto SlingHttpServletRequest que se puede utilizar para obtener finalmente el WorkflowSession objeto; por ejemplo:
var wfsession = sling.getRequest().getResource().getResourceResolver().adaptTo(Packages.com.adobe.granite.workflow.WorkflowSession);

Uso de la API de flujo de trabajo REST

La consola Flujo de trabajo utiliza en gran medida la API de REST; esta página describe la API de REST para flujos de trabajo.
La herramienta de línea de comandos curl le permite utilizar la API de flujo de trabajo REST para acceder a los objetos de flujo de trabajo y administrar los ciclos de vida de las instancias. Los ejemplos de esta página muestran el uso de la API de REST a través de la herramienta de línea de comandos curl.
Las siguientes acciones son compatibles con la API de REST:
Al utilizar Firebug, una extensión de Firefox para el desarrollo web, es posible seguir el tráfico HTTP cuando se opera la consola. Por ejemplo, puede comprobar los parámetros y los valores enviados al servidor AEM con una POST solicitud.
En esta página se da por hecho que AEM se ejecuta en localhost en el puerto 4502 y que el contexto de instalación es " / " (raíz). Si no es el caso de su instalación, los URI, a los que se aplican las solicitudes HTTP, deben adaptarse en consecuencia.
El procesamiento admitido para GET las solicitudes es el procesamiento JSON. Las direcciones URL para GET deben tener la .json extensión, por ejemplo:
http://localhost:4502/etc/workflow.json

Administración de instancias de flujo de trabajo

Los siguientes métodos de solicitud HTTP se aplican a:
http://localhost:4502/etc/workflow/instances
Método de solicitud HTTP Acciones
GET Muestra las instancias de flujo de trabajo disponibles.
POST
Crea una nueva instancia de flujo de trabajo. Los parámetros son: - model : el ID (URI) del modelo de flujo de trabajo correspondiente: payloadType : que contiene el tipo de carga útil (por ejemplo, JCR_PATH o dirección URL). La carga útil se envía como parámetro payload . Se devuelve una respuesta 201 ( CREATED ) con un encabezado de ubicación que contiene la dirección URL del nuevo recurso de instancia de flujo de trabajo.

Administración de una instancia de flujo de trabajo según su estado

Los siguientes métodos de solicitud HTTP se aplican a:
http://localhost:4502/etc/workflow/instances.{state}
Método de solicitud HTTP
Acciones
GET
Enumera las instancias de flujo de trabajo disponibles y sus estados ( RUNNING , SUSPENDED , ABORTED o COMPLETED )

Administración de una instancia de flujo de trabajo por su ID

Los siguientes métodos de solicitud HTTP se aplican a:
http://localhost:4502/etc/workflow/instances/{id}
Método de solicitud HTTP Acciones
GET Obtiene los datos de instancias (definición y metadatos), incluido el vínculo al modelo de flujo de trabajo correspondiente.
POST Cambia el estado de la instancia. El nuevo estado se envía como parámetro state y debe tener uno de los siguientes valores: RUNNING , SUSPENDED o ABORTED . Si el nuevo estado no está disponible (por ejemplo, al suspender una instancia terminada), se devuelve una 409 ( CONFLICT ) respuesta al cliente.

Administración de modelos de flujo de trabajo

Los siguientes métodos de solicitud HTTP se aplican a:
http://localhost:4502/etc/workflow/models
Método de solicitud HTTP Acciones
GET Enumera los modelos de flujo de trabajo disponibles.
POST Crea un nuevo modelo de flujo de trabajo. Si title se envía el parámetro, se crea un nuevo modelo con el título especificado. Al adjuntar una definición de modelo JSON como parámetro, model se crea un nuevo modelo de flujo de trabajo según la definición proporcionada. Se devuelve una 201 respuesta ( CREATED ) con un encabezado de ubicación que contiene la dirección URL del nuevo recurso del modelo de flujo de trabajo. Lo mismo ocurre cuando se adjunta una definición de modelo como un parámetro de archivo denominado modelfile . Tanto en el caso de los parámetros model como en el modelfile , se requiere un parámetro adicional denominado type para definir el formato de serialización. Los nuevos formatos de serialización se pueden integrar mediante la API OSGI. Se entrega un serializador JSON estándar con el motor de flujo de trabajo. Su tipo es JSON. Consulte a continuación un ejemplo del formato.
Ejemplo: en el navegador, una solicitud para http://localhost:4502/etc/workflow/models.json generar una respuesta json similar a la siguiente:
[
    {"uri":"/var/workflow/models/activationmodel"}
    ,{"uri":"/var/workflow/models/dam/adddamsize"}
    ,{"uri":"/var/workflow/models/cloudconfigs/dtm-reactor/library-download"}
    ,{"uri":"/var/workflow/models/ac-newsletter-workflow-simple"}
    ,{"uri":"/var/workflow/models/dam/dam-create-language-copy"}
    ,{"uri":"/var/workflow/models/dam/dam-create-and-translate-language-copy"}
    ,{"uri":"/var/workflow/models/dam-indesign-proxy"}
    ,{"uri":"/var/workflow/models/dam-xmp-writeback"}
    ,{"uri":"/var/workflow/models/dam-parse-word-documents"}
    ,{"uri":"/var/workflow/models/dam/process_subasset"}
    ,{"uri":"/var/workflow/models/dam/dam_set_last_modified"}
    ,{"uri":"/var/workflow/models/dam/dam-autotag-assets"}
    ,{"uri":"/var/workflow/models/dam/update_asset"}
    ,{"uri":"/var/workflow/models/dam/update_asset_offloading"}
    ,{"uri":"/var/workflow/models/dam/dam-update-language-copy"}
    ,{"uri":"/var/workflow/models/dam/update_from_lightbox"}
    ,{"uri":"/var/workflow/models/cloudservices/DTM_bundle_download"}
    ,{"uri":"/var/workflow/models/dam/dam_download_asset"}
    ,{"uri":"/var/workflow/models/dam/dynamic-media-encode-video"}
    ,{"uri":"/var/workflow/models/dam/dynamic-media-video-thumbnail-replacement"}
    ,{"uri":"/var/workflow/models/dam/dynamic-media-video-user-uploaded-thumbnail"}
    ,{"uri":"/var/workflow/models/newsletter_bounce_check"}
    ,{"uri":"/var/workflow/models/projects/photo_shoot_submission"}
    ,{"uri":"/var/workflow/models/projects/product_photo_shoot"}
    ,{"uri":"/var/workflow/models/projects/approval_workflow"}
    ,{"uri":"/var/workflow/models/prototype-01"}
    ,{"uri":"/var/workflow/models/publish_example"}
    ,{"uri":"/var/workflow/models/publish_to_campaign"}
    ,{"uri":"/var/workflow/models/screens/publish_to_author_bin"}
    ,{"uri":"/var/workflow/models/s7dam/request_to_publish_to_youtube"}
    ,{"uri":"/var/workflow/models/projects/request_copy"}
    ,{"uri":"/var/workflow/models/projects/request_email"}
    ,{"uri":"/var/workflow/models/projects/request_landing_page"}
    ,{"uri":"/var/workflow/models/projects/request_launch"}
    ,{"uri":"/var/workflow/models/request_for_activation"}
    ,{"uri":"/var/workflow/models/request_for_deactivation"}
    ,{"uri":"/var/workflow/models/request_for_deletion"}
    ,{"uri":"/var/workflow/models/request_for_deletion_without_deactivation"}
    ,{"uri":"/var/workflow/models/request_to_complete_move_operation"}
    ,{"uri":"/var/workflow/models/reverse_replication"}
    ,{"uri":"/var/workflow/models/salesforce-com-export"}
    ,{"uri":"/var/workflow/models/scene7"}
    ,{"uri":"/var/workflow/models/scheduled_activation"}
    ,{"uri":"/var/workflow/models/scheduled_deactivation"}
    ,{"uri":"/var/workflow/models/screens/screens-update-asset"}
    ,{"uri":"/var/workflow/models/translation"}
    ,{"uri":"/var/workflow/models/s7dam/request_to_remove_from_youtube"}
    ,{"uri":"/var/workflow/models/wcm-translation/create_language_copy"}
    ,{"uri":"/var/workflow/models/wcm-translation/prepare_translation_project"}
    ,{"uri":"/var/workflow/models/wcm-translation/translate-i18n-dictionary"}
    ,{"uri":"/var/workflow/models/wcm-translation/sync_translation_job"}
    ,{"uri":"/var/workflow/models/wcm-translation/translate-language-copy"}
    ,{"uri":"/var/workflow/models/wcm-translation/update_language_copy"}
]

Administración de un modelo de flujo de trabajo específico

Los siguientes métodos de solicitud HTTP se aplican a:
http://localhost:4502*{uri}*
Dónde *{uri}* está la ruta al nodo de modelo en el repositorio.
Método de solicitud HTTP Acciones
GET Obtiene la HEAD versión del modelo (definición y metadatos).
PUT Actualiza la HEAD versión del modelo (crea una nueva versión). La definición completa del modelo para la nueva versión del modelo debe agregarse como un parámetro llamado model . Además, se necesita un type parámetro como al crear nuevos modelos y debe tener el valor JSON .
POST El mismo comportamiento que con PUT. Necesario porque las utilidades de AEM no admiten PUT operaciones.
DELETE Elimina el modelo. Para resolver los problemas de firewall o proxy, también se aceptará como POST solicitud una entrada de encabezado que contenga una entrada X-HTTP-Method-Override con valor DELETE DELETE .
Ejemplo: en el navegador, una solicitud para http://localhost:4502/var/workflow/models/publish_example.json devolver una json respuesta similar al siguiente código:
{
  "id":"/var/workflow/models/publish_example",
  "title":"Publish Example",
  "version":"1.0",
  "description":"This example shows a simple review and publish process.",
  "metaData":
  {
    "multiResourceSupport":"true",
    "tags":"wcm,publish"
  },
  "nodes":
  [{
    "id":"node0",
    "type":"START",
    "title":"Start",
    "description":"The start node of the workflow.",
    "metaData":
    {
    }
  },
  {
    "id":"node1",
    "type":"PARTICIPANT",
    "title":"Validate Content",
    "description":"Validate the modified content.",
    "metaData":
    {
      "PARTICIPANT":"admin"
    }
  },
  {
    "id":"node2",
    "type":"PROCESS",
    "title":"Publish Content",
    "description":"Publish the modified content.",
    "metaData":
    {
      "PROCESS_AUTO_ADVANCE":"true",
      "PROCESS":"com.day.cq.wcm.workflow.process.ActivatePageProcess"
    }
  },
  {
    "id":"node3",
    "type":"END",
    "title":"End",
    "description":"The end node of the workflow.",
    "metaData":
    {
    }
  }],
  "transitions":
  [{
    "from":"node0",
    "to":"node1",
    "metaData":
    {
    }
  },
  {
    "from":"node1",
    "to":"node2",
    "metaData":
    {
    }
  },
  {
    "from":"node2",
    "to":"node3",
    "metaData":
    {
    }
  }
]}

Administración de un modelo de flujo de trabajo según su versión

Los siguientes métodos de solicitud HTTP se aplican a:
http://localhost:4502/etc/workflow/models/{id}.{version}
Método de solicitud HTTP
Acciones
GET
Obtiene los datos del modelo en la versión dada (si existe).

Administración de bandejas de entrada (de usuario)

Los siguientes métodos de solicitud HTTP se aplican a:
http://localhost:4502/bin/workflow/inbox
Método de solicitud HTTP Acciones
GET Enumera los elementos de trabajo que se encuentran en la bandeja de entrada del usuario, que se identifican mediante los encabezados de autenticación HTTP.
POST Completa el elemento de trabajo cuyo URI se envía como parámetro item y avanza la instancia de flujo de trabajo de acuerdo a los nodos siguientes, que se definen mediante el parámetro route o backroute en caso de retroceder un paso. Si delegatee se envía el parámetro, el elemento de trabajo identificado por el parámetro item se delega al participante especificado.

Administración de una bandeja de entrada (de usuario) mediante el ID de elemento de trabajo

Los siguientes métodos de solicitud HTTP se aplican a:
http://localhost:4502/bin/workflow/inbox/{id}
Método de solicitud HTTP
Acciones
GET
Obtiene los datos (definición y metadatos) de la bandeja de entrada WorkItem identificados por su ID.

Ejemplos

Cómo obtener una lista de todos los flujos de trabajo en ejecución con sus ID

Para obtener una lista de todos los flujos de trabajo en ejecución, realice una de las siguientes acciones:
http://localhost:4502/etc/workflow/instances.RUNNING.json

Cómo obtener una lista de todos los flujos de trabajo en ejecución con sus ID: REST mediante curl

Ejemplo con curl:
curl -u admin:admin http://localhost:4502/etc/workflow/instances.RUNNING.json

El uri que se muestra en los resultados puede utilizarse como instancia id en otros comandos; por ejemplo:
[
    {"uri":"/etc/workflow/instances/server0/2017-03-08/request_for_activation_1"}
]

Este curl comando se puede utilizar con cualquier estado de flujo de trabajo en lugar de RUNNING .

Cómo cambiar el título del flujo de trabajo

Para cambiar el Título del flujo de trabajo que se muestra en la ficha Instancias de la consola de flujo de trabajo, envíe un POST comando:
  • hasta: http://localhost:4502/etc/workflow/instances/{id}
  • con los parámetros siguientes:
    • action :: su valor debe ser: UPDATE
    • workflowTitle :: el título del flujo de trabajo

Cómo cambiar el título del flujo de trabajo - REST mediante curl

Ejemplo con curl:
curl -u admin:admin -d "action=UPDATE&workflowTitle=myWorkflowTitle" http://localhost:4502/etc/workflow/instances/{id}

# for example
curl -u admin:admin -d "action=UPDATE&workflowTitle=myWorkflowTitle" http://localhost:4502/etc/workflow/instances/server0/2017-03-08/request_for_activation_1

Cómo enumerar todos los modelos de flujo de trabajo

Para obtener una lista de todos los modelos de flujo de trabajo disponibles, realice una operación GET para:
http://localhost:4502/etc/workflow/models.json

Cómo enumerar todos los modelos de flujo de trabajo: REST mediante curl

Ejemplo con curl:
curl -u admin:admin http://localhost:4502/etc/workflow/models.json

Consulte también Administración de modelos de flujo de trabajo.

Obtención de un objeto WorkflowSession

La com.adobe.granite.workflow.WorkflowSession clase se puede adaptar desde un javax.jcr.Session objeto o un org.apache.sling.api.resource.ResourceResolver objeto.

Obtención de un objeto WorkflowSession: Java

En una secuencia de comandos JSP (o código Java para una clase servlet), utilice el objeto de solicitud HTTP para obtener un SlingHttpServletRequest objeto, que proporciona acceso a un ResourceResolver objeto. Adaptar el ResourceResolver objeto a WorkflowSession .
<%
%><%@include file="/libs/foundation/global.jsp"%><%
%><%@page session="false"
    import="com.adobe.granite.workflow.WorkflowSession,
  org.apache.sling.api.SlingHttpServletRequest"%><%

SlingHttpServletRequest slingReq = (SlingHttpServletRequest)request;
WorkflowSession wfSession = slingReq.getResourceResolver().adaptTo(WorkflowSession.class);
%>

Obtención de un objeto WorkflowSession: secuencia de comandos de ECMA

Utilice la sling variable para obtener el SlingHttpServletRequest objeto que utiliza para obtener un ResourceResolver objeto. Adaptar el ResourceResolver objeto al WorkflowSession objeto.
var wfsession = sling.getRequest().getResource().getResourceResolver().adaptTo(Packages.com.adobe.granite.workflow.WorkflowSession);

Creación, lectura o eliminación de modelos de flujo de trabajo

Los siguientes ejemplos muestran cómo acceder a los modelos de flujo de trabajo:
  • El código para Java y secuencias de comandos ECMA utiliza el WorkflowSession.createNewModel método .
  • El comando curl accede al modelo directamente mediante su URL.
Los ejemplos utilizados:
  1. Cree un modelo (con el ID /var/workflow/models/mymodel/jcr:content/model ).
  2. Elimine el modelo.
Al eliminar el modelo, se establece la deleted propiedad del nodo secundario del metaData modelo en true .
La eliminación no elimina el nodo de modelo.
Al crear un modelo nuevo:
  • El editor de modelos de flujo de trabajo requiere que los modelos utilicen una estructura de nodos específica a continuación /var/workflow/models . El nodo principal del modelo debe ser del tipo cq:Page que tenga un jcr:content nodo con los siguientes valores de propiedad:
    • sling:resourceType : cq/workflow/components/pages/model
    • cq:template : /libs/cq/workflow/templates/model
    Al crear un modelo, primero debe crear este cq:Page nodo y utilizar su jcr:content nodo como el nodo principal del modelo.
  • El id argumento que algunos métodos requieren para identificar el modelo es la ruta absoluta del nodo de modelo en el repositorio:
    /var/workflow/models/<*model_name>*/jcr:content/model
    Consulte Cómo enumerar todos los modelos de flujo de trabajo.

Creación, lectura o eliminación de modelos de flujo de trabajo: Java

<%@include file="/libs/foundation/global.jsp"%><%
%><%@page session="false" import="com.adobe.granite.workflow.WorkflowSession,
                 com.adobe.granite.workflow.model.WorkflowModel,
             org.apache.sling.api.SlingHttpServletRequest"%><%

SlingHttpServletRequest slingReq = (SlingHttpServletRequest)request;
WorkflowSession wfSession = slingReq.getResourceResolver().adaptTo(WorkflowSession.class);
/* Create the parent page */
String modelRepo = new String("/var/workflow/models");
String modelTemplate = new String ("/libs/cq/workflow/templates/model");
String modelName = new String("mymodel");
Page modelParent = pageManager.create(modelRepo, modelName, modelTemplate, "My workflow model");

/* create the model */
String modelId = new String(modelParent.getPath()+"/jcr:content/model")
WorkflowModel model = wfSession.createNewModel("Made using Java",modelId);

/* delete the model */
wfSession.deleteModel(modelId);
%>

Creación, lectura o eliminación de modelos de flujo de trabajo: secuencia de comandos de ECMA

var resolver = sling.getRequest().getResource().getResourceResolver();
var wfSession = resolver.adaptTo(Packages.com.adobe.granite.workflow.WorkflowSession);
var pageManager = resolver.adaptTo(Packages.com.day.cq.wcm.api.PageManager);

//create the parent page node
var workflowPage = pageManager.create("/var/workflow/models", "mymodel", "/libs/cq/workflow/templates/model", "Created via ECMA Script");
var modelId = workflowPage.getPath()+ "/jcr:content/model";
//create the model
var model = wfSession.createNewModel("My Model", modelId);
//delete the model
var model = wfSession.deleteModel(modelId);

Eliminación de un modelo de flujo de trabajo: REST mediante cursiva

# deleting the model by its id
curl -u admin:admin -X DELETE http://localhost:4502/etc/workflow/models/{id}

Debido al nivel de detalle requerido, el curl no se considera práctico para crear y/o leer un modelo.

Filtrar flujos de trabajo del sistema al comprobar el estado del flujo de trabajo

Puede utilizar la API WorkflowStatus.html WorkflowStatus para recuperar información sobre el estado del flujo de trabajo de un nodo.
Varios métodos tienen el parámetro:
excludeSystemWorkflows
Este parámetro se puede establecer en true para indicar que los flujos de trabajo del sistema deben excluirse de los resultados relevantes.
Se puede actualizar la configuración OSGi Adobe Granite Workflow PayloadMapCache que especifica el flujo de trabajo Models que se considerará como flujos de trabajo del sistema. Los modelos de flujo de trabajo predeterminados (tiempo de ejecución) son:
  • /var/workflow/models/scheduled_activation/jcr:content/model
  • /var/workflow/models/scheduled_deactivation/jcr:content/model

Avance automático del participante tras un tiempo de espera

Si necesita avanzar automáticamente un paso de participante que no se haya completado en un tiempo predefinido, puede:
  1. Implemente un detector de eventos OSGI para escuchar la creación y modificación de tareas.
  2. Especifique un tiempo de espera (fecha límite) y, a continuación, cree un trabajo de sling programado para que se active en ese momento.
  3. Escriba un controlador de trabajo que reciba una notificación cuando caduque el tiempo de espera y active el trabajo.
    Este controlador realizará la acción necesaria en la tarea si la tarea aún no se ha completado
Las medidas que deben adoptarse deben definirse claramente para poder utilizar este enfoque.

Interactuar con instancias de flujo de trabajo

A continuación se proporcionan ejemplos básicos de cómo interactuar (de forma programada) con instancias de flujo de trabajo.

Interactuar con instancias de flujo de trabajo: Java

// starting a workflow
WorkflowModel model = wfSession.getModel(workflowId);
WorkflowData wfData = wfSession.newWorkflowData("JCR_PATH", repoPath);
wfSession.startWorkflow(model, wfData);

// querying and managing a workflow
Workflow[] workflows workflows = wfSession.getAllWorkflows();
Workflow workflow= wfSession.getWorkflow(id);
wfSession.suspendWorkflow(workflow);
wfSession.resumeWorkflow(workflow);
wfSession.terminateWorkflow(workflow);

Interactuar con instancias de flujo de trabajo: secuencia de comandos de ECMA

// starting a workflow
var model = wfSession.getModel(workflowId);
var wfData = wfSession.newWorkflowData("JCR_PATH", repoPath);
wfSession.startWorkflow(model, wfData);

// querying and managing a workflow
var workflows = wfSession.getWorkflows(“RUNNING“);
var workflow= wfSession.getWorkflow(id);
wfSession.suspendWorkflow(workflow);
wfSession.resumeWorkflow(workflow);
wfSession.terminateWorkflow(workflow);

Interactuar con instancias de flujo de trabajo: REST con curl

  • Inicio de un flujo de trabajo
    # starting a workflow
    curl -d "model={id}&payloadType={type}&payload={payload}" http://localhost:4502/etc/workflow/instances
    
    # for example:
    curl -u admin:admin -d "model=/var/workflow/models/request_for_activation/jcr:content/model&payloadType=JCR_PATH&payload=/content/we-retail/us/en/products" http://localhost:4502/etc/workflow/instances
    
    
  • Lista de instancias
    # listing the instances
    curl -u admin:admin http://localhost:4502/etc/workflow/instances.json
    
    
    Se enumerarán todas las instancias; por ejemplo:
    [
        {"uri":"/var/workflow/instances/server0/2018-02-26/prototype-01_1"}
        ,{"uri":"/var/workflow/instances/server0/2018-02-26/prototype-01_2"}
    ]
    
    
    Consulte Cómo obtener una lista de todos los flujos de trabajo en ejecución con sus ID para enumerar las instancias con un estado específico.
  • Suspensión de un flujo de trabajo
    # suspending a workflow
    curl -d "state=SUSPENDED" http://localhost:4502/etc/workflow/instances/{id}
    
    # for example:
    curl -u admin:admin -d "state=SUSPENDED" http://localhost:4502/etc/workflow/instances/server0/2017-03-08/request_for_activation_1
    
    
  • Reanudación de un flujo de trabajo
    # resuming a workflow
    curl -d "state=RUNNING" http://localhost:4502/etc/workflow/instances/{id}
    
    # for example:
    curl -u admin:admin -d "state=RUNNING" http://localhost:4502/etc/workflow/instances/server0/2017-03-08/request_for_activation_1
    
    
  • Finalización de una instancia de flujo de trabajo
    # terminating a workflow
    curl -d "state=ABORTED" http://localhost:4502/etc/workflow/instances/{id}
    
    # for example:
    curl -u admin:admin -d "state=ABORTED" http://localhost:4502/etc/workflow/instances/server0/2017-03-08/request_for_activation_1
    
    

Interactuar con elementos de trabajo

A continuación se proporcionan ejemplos básicos de cómo interactuar (de forma programada) con elementos de trabajo.

Interactuar con elementos de trabajo: Java

// querying work items
WorkItem[] workItems = wfSession.getActiveWorkItems();
WorkItem workItem = wfSession.getWorkItem(id);

// getting routes
List<Route> routes = wfSession.getRoutes(workItem);

// delegating
Iterator<Participant> delegatees = wfSession.getDelegatees(workItem);
wfSession.delegateWorkItem(workItem, delegatees.get(0));

// completing or advancing to the next step
wfSession.complete(workItem, routes.get(0));

Interactuar con elementos de trabajo: secuencia de comandos de ECMA

// querying work items
var workItems = wfSession.getActiveWorkItems();
var workItem = wfSession.getWorkItem(id);

// getting routes
var routes = wfSession.getRoutes(workItem);

// delegating
var delegatees = wfSession.getDelegatees(workItem);
wfSession.delegateWorkItem(workItem, delegatees.get(0));

// completing or advancing to the next step
wfSession.complete(workItem, routes.get(0));

Interactuar con elementos de trabajo: REST mediante cursiva

  • Lista de elementos de trabajo de la bandeja de entrada
    # listing the work items
    curl -u admin:admin http://localhost:4502/bin/workflow/inbox
    
    
    Se enumerarán los detalles de los elementos de trabajo que se encuentran actualmente en la Bandeja de entrada; por ejemplo:
    [{
        "uri_xss": "/var/workflow/instances/server0/2018-02-26/prototype-01_2/workItems/node2_var_workflow_instances_server0_2018-02-26_prototype-01_2",
        "uri": "/var/workflow/instances/server0/2018-02-26/prototype-01_2/workItems/node2_var_workflow_instances_server0_2018-02-26_prototype-01_2",
        "currentAssignee_xss": "workflow-administrators",
        "currentAssignee": "workflow-administrators",
        "startTime": 1519656289274,
        "payloadType_xss": "JCR_PATH",
        "payloadType": "JCR_PATH",
        "payload_xss": "/content/we-retail/es/es",
        "payload": "/content/we-retail/es/es",
        "comment_xss": "Process resource is null",
        "comment": "Process resource is null",
        "type_xss": "WorkItem",
        "type": "WorkItem"
      },{
        "uri_xss": "configuration/configure_analyticstargeting",
        "uri": "configuration/configure_analyticstargeting",
        "currentAssignee_xss": "administrators",
        "currentAssignee": "administrators",
        "type_xss": "Task",
        "type": "Task"
      },{
        "uri_xss": "configuration/securitychecklist",
        "uri": "configuration/securitychecklist",
        "currentAssignee_xss": "administrators",
        "currentAssignee": "administrators",
        "type_xss": "Task",
        "type": "Task"
      },{
        "uri_xss": "configuration/enable_collectionofanonymoususagedata",
        "uri": "configuration/enable_collectionofanonymoususagedata",
        "currentAssignee_xss": "administrators",
        "currentAssignee": "administrators",
        "type_xss": "Task",
        "type": "Task"
      },{
        "uri_xss": "configuration/configuressl",
        "uri": "configuration/configuressl",
        "currentAssignee_xss": "administrators",
        "currentAssignee": "administrators",
        "type_xss": "Task",
        "type": "Task"
      }
    
    
  • Delegación de elementos de trabajo
    # delegating
    curl -d "item={item}&delegatee={delegatee}" http://localhost:4502/bin/workflow/inbox
    
    # for example:
    curl -u admin:admin -d "item=/etc/workflow/instances/server0/2017-03-08/request_for_activation_1/workItems/node1_etc_workflow_instances_server0_2017-03-08_request_for_act_1&delegatee=administrators" http://localhost:4502/bin/workflow/inbox
    
    
    La opción delegatee debe ser válida para el paso del flujo de trabajo.
  • Cómo completar o avanzar elementos de trabajo al paso siguiente
    # retrieve the list of routes; the results will be similar to {"results":1,"routes":[{"rid":"233123169","label":"End","label_xss":"End"}]}
    http://localhost:4502/etc/workflow/instances/<path-to-the-workitem>.routes.json
    
    # completing or advancing to the next step; use the appropriate route ID (rid value) from the above list
    curl -d "item={item}&route={route}" http://localhost:4502/bin/workflow/inbox
    
    # for example:
    curl -u admin:admin -d "item=/etc/workflow/instances/server0/2017-03-08/request_for_activation_1/workItems/node1_etc_workflow_instances_server0_2017-03-08_request_for_activation_1&route=233123169" http://localhost:4502/bin/workflow/inbox
    
    

Escucha de eventos de flujo de trabajo

Utilice el marco de eventos OSGi para escuchar los eventos que define la com.adobe.granite.workflow.event.WorkflowEvent clase. Esta clase también proporciona varios métodos útiles para obtener información sobre el tema del evento. Por ejemplo, el getWorkItem método devuelve el WorkItem objeto del elemento de trabajo que participa en el evento.
El siguiente código de ejemplo define un servicio que escucha eventos de flujo de trabajo y realiza tareas según el tipo de evento.
package com.adobe.example.workflow.listeners;

import org.apache.sling.event.jobs.JobProcessor;
import org.apache.sling.event.jobs.JobUtil;

import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

import com.adobe.granite.workflow.event.WorkflowEvent;
import com.adobe.granite.workflow.exec.WorkItem;

/**
 * The <code>WorkflowEventCatcher</code> class listens to workflow events.
 */
@Component(metatype=false, immediate=true)
@Service(value=org.osgi.service.event.EventHandler.class)
public class WorkflowEventCatcher implements EventHandler, JobProcessor {

 @Property(value=com.adobe.granite.workflow.event.WorkflowEvent.EVENT_TOPIC)
 static final String EVENT_TOPICS = "event.topics";

 private static final Logger logger = LoggerFactory.getLogger(WorkflowEventCatcher.class);

 public void handleEvent(Event event) {
  JobUtil.processJob(event, this);
 }

 public boolean process(Event event) {
  logger.info("Received event of topic: " + event.getTopic());
  String topic = event.getTopic();

  try {
   if (topic.equals(WorkflowEvent.EVENT_TOPIC)) {
    WorkflowEvent wfevent = (WorkflowEvent)event;
    String eventType = wfevent.getEventType();
    String instanceId = wfevent.getWorkflowInstanceId();

    if (instanceId != null) {
     //workflow instance events
     if (eventType.equals(WorkflowEvent.WORKFLOW_STARTED_EVENT) ||
       eventType.equals(WorkflowEvent.WORKFLOW_RESUMED_EVENT) ||
       eventType.equals(WorkflowEvent.WORKFLOW_SUSPENDED_EVENT)) {
      // your code comes here...
     } else if (
       eventType.equals(WorkflowEvent.WORKFLOW_ABORTED_EVENT) ||
       eventType.equals(WorkflowEvent.WORKFLOW_COMPLETED_EVENT)) {
      // your code comes here...
     }
     // workflow node event
     if (eventType.equals(WorkflowEvent.NODE_TRANSITION_EVENT)) {
      WorkItem currentItem = (WorkItem) event.getProperty(WorkflowEvent.WORK_ITEM);
      // your code comes here...
     }
    }
   }
  } catch(Exception e){
   logger.debug(e.getMessage());
   e.printStackTrace();
  }
  return true;
 }
}