Utveckla projekt i AEM

Senaste uppdatering: 2023-05-22

Ämnen:
Projects
Visa mer om det här ämnet
Workflow
Visa mer om det här ämnet

Skapat för:
Beginner

Developer

Det här är en självstudiekurs om utveckling som visar hur du utvecklar för AEM Projects. I den här självstudiekursen skapar vi en anpassad projektmall som kan användas för att skapa nya projekt i AEM för att hantera arbetsflöden och uppgifter för innehållsredigering.

Den här videon ger en kort demonstration av det färdiga arbetsflödet som skapas i självstudien nedan.

Introduktion

AEM Projects är en funktion i AEM som gör det enklare att hantera och gruppera alla arbetsflöden och uppgifter som är kopplade till innehållsskapande som en del av en AEM Sites- eller Assets-implementering.

AEM innehåller flera OTB-projektmallar. När du skapar ett nytt projekt kan författarna välja bland dessa tillgängliga mallar. Stora AEM implementeringar med unika affärskrav vill skapa anpassade projektmallar som är anpassade efter deras behov. Genom att skapa en anpassad projektmall kan utvecklare konfigurera projektkontrollpanelen, ansluta till anpassade arbetsflöden och skapa ytterligare affärsroller för ett projekt. Vi ska titta närmare på strukturen för en projektmall och skapa en exempelmall.

Anpassat projektkort

Inställningar

Den här självstudiekursen stegar igenom koden som behövs för att skapa en anpassad projektmall. Du kan hämta och installera bifogat paket till en lokal miljö att följa med i självstudiekursen. Du kan även komma åt hela Maven-projektet som finns på GitHub.

Den här självstudiekursen förutsätter vissa grundläggande kunskaper i AEM och viss vana vid AEM Maven-projektinställningar. All kod som nämns är avsedd att användas som referens och ska endast distribueras till en lokal AEM.

Struktur för en projektmall

Projektmallar ska placeras under källkontroll och finnas under programmappen under /apps. De bör helst placeras i en undermapp med namnkonventionen för */projects/templates/<my-template>. Genom att använda den här namnkonventionen blir alla nya anpassade mallar automatiskt tillgängliga för författare när de skapar ett projekt. Konfigurationen av tillgängliga projektmallar är: /content/projects/jcr:content noden efter cq:allowedTemplates -egenskap. Som standard är detta ett reguljärt uttryck: /(apps|libs)/.*/projects/templates/.*

Rotnoden för en projektmall har en jcr:primärType av cq:Template. Under rotnoden finns tre noder: gadgets, roller och arbetsflöden. De här noderna är alla nt:ostrukturerad. Under rotnoden kan även en miniatyrbild.png-fil visas när du väljer mallen i guiden Skapa projekt.

Den fullständiga nodstrukturen:

/apps/<my-app>
    + projects (nt:folder)
         + templates (nt:folder)
              + <project-template-root> (cq:Template)
                   + gadgets (nt:unstructured)
                   + roles (nt:unstructured)
                   + workflows (nt:unstructured)

Projektmallsrot

Projektmallens rotnod är av typen cq:Template. På den här noden kan du konfigurera egenskaper jcr:title och jcr:description som visas i guiden Skapa projekt. Det finns också en egenskap som heter guide som pekar på ett formulär som fyller i projektets egenskaper. Standardvärdet för: /libs/cq/core/content/projects/wizard/steps/defaultproject.html fungerar bra i de flesta fall eftersom användaren kan fylla i de grundläggande projektegenskaperna och lägga till gruppmedlemmar.

*Observera att serververktyget Skapa projekt inte använder POSTEN Sling. Värden bokförs i stället på en anpassad servlet:com.adobe.cq.projects.impl.servlet.ProjectServlet. Detta bör beaktas när du lägger till anpassade fält.

Ett exempel på en anpassad guide finns för översättningsprojektmallen: /libs/cq/core/content/projects/wizard/translationproject/defaultproject.

Gadgets

Det finns inga ytterligare egenskaper på den här noden, men de underordnade objekten för gadgetnoden kontrollerar vilka projektpaneler som fyller i projektkontrollpanelen när ett nytt projekt skapas. Projektpaneler (kallas även gadgets eller poder) är enkla kort som fyller i en arbetsplats i ett projekt. En fullständig lista med flikpaneler finns under: /libs/cq/gui/components/projects/admin/pod.  Projektägare kan alltid lägga till/ta bort paneler när ett projekt har skapats.

Roller

Det finns 3 standardroller för varje projekt: Observatörer, Redigerare och Ägare. Genom att lägga till underordnade noder under rollnoden kan du lägga till ytterligare företagsspecifika projektroller för mallen. Du kan sedan koppla rollerna till specifika arbetsflöden som är kopplade till projektet.

Arbetsflöden

Ett av de mest lockande skälen till att du skapar en anpassad projektmall är att du kan konfigurera tillgängliga arbetsflöden för projektet. Dessa kan vara OTB-arbetsflöden eller anpassade arbetsflöden. Under arbetsflöden nod där måste vara en modeller nod (även nt:unstructured) och underordnade noder under anger de tillgängliga arbetsflödesmodellerna. Egenskapen modelId  pekar på arbetsflödesmodellen under /etc/workflow och egenskapen guide pekar på den dialogruta som används när arbetsflödet startas. En stor fördel med Projekt är möjligheten att lägga till en anpassad dialogruta (guide) för att hämta företagsspecifika metadata i början av arbetsflödet som kan driva vidare åtgärder i arbetsflödet.

<projects-template-root> (cq:Template)
    + workflows (nt:unstructured)
         + models (nt:unstructured)
              + <workflow-model> (nt:unstructured)
                   - modelId = points to the workflow model
                   - wizard = dialog used to start the workflow

Skapa en projektmall

Eftersom vi huvudsakligen kopierar/konfigurerar noder kommer vi att använda CRXDE Lite. Öppna den lokala AEM instansen CRXDE Lite.

Börja med att skapa en ny mapp under /apps/<your-app-folder> namngiven projects. Skapa en annan mapp under namnet templates.

/apps/aem-guides/projects-tasks/
                    + projects (nt:folder)
                             + templates (nt:folder)

För att göra det enklare kommer vi att starta vår anpassade mall från den befintliga mallen för enkla projekt.
1. Kopiera och klistra in noden /libs/cq/core/content/projects/templates/default under mallar som skapades i steg 1.
```
/apps/aem-guides/projects-tasks/
             + templates (nt:folder)
                  + default (cq:Template)
```

Nu bör du ha en bana som /apps/aem-guides/projects-tasks/projects/templates/authoring-project.

Redigera jcr:title och jcr:description egenskaper för utvecklarprojektnoden till anpassade titel- och beskrivningsvärden.
1. Lämna guide egenskap som pekar på standardprojektegenskaperna.

/apps/aem-guides/projects-tasks/projects/
         + templates (nt:folder)
              + authoring-project (cq:Template)
                   - jcr:title = "Authoring Project"
                   - jcr:description = "A project to manage approval and publish process for AEM Sites or Assets"
                   - wizard = "/libs/cq/core/content/projects/wizard/steps/defaultproject.html"

För den här projektmallen vill vi använda uppgifter.

Lägg till en ny nt:ostrukturerad nod under authoring-project/gadgets anropade uppgifter.
Lägg till String-egenskaper i aktivitetsnoden för cardWeight = "100", jcr:title="Uppgifter", och sling:resourceType="cq/gui/components/projects/admin/pod/taskpod".

Nu Aktivitetspanelen visas som standard när ett nytt projekt skapas.

../projects/templates/authoring-project
    + gadgets (nt:unstructured)
         + team (nt:unstructured)
         + asset (nt:unstructured)
         + work (nt:unstructured)
         + experiences (nt:unstructured)
         + projectinfo (nt:unstructured)
         ..
         + tasks (nt:unstructured)
              - cardWeight = "100"
              - jcr:title = "Tasks"
              - sling:resourceType = "cq/gui/components/projects/admin/pod/taskpod"

Vi ska lägga till en anpassad godkännarroll i vår projektmall.
1. Under projektmallsnoden (authoring-project) lägger du till en ny nt:ostrukturerad nod med etikett roller.
2. Lägg till ytterligare nt:ostrukturerad noden som kallas godkännare som underordnad till rollnoden.
3. Lägg till String-egenskaper jcr:title = "Godkännare", roleclass ="ägare", roleid="godkännare".
  1. Namnet på godkännarnoden, samt jcr:title och roleid, kan vara vilket strängvärde som helst (så länge som roleid är unikt).
  2. roleclass styr behörigheter för den rollen baserat på 3 OTB-roller: ägare, redigerare och observatör.
  3. I allmänhet kan rollklassen vara Ägare. om det är en mer specifik redigeringsroll som fotografen eller Designer redigerare bör det räcka med en rollklass. Den stora skillnaden mellan ägare och redigerare är att projektägare kan uppdatera projektegenskaperna och lägga till nya användare i projektet.
```
../projects/templates/authoring-project
    + gadgets (nt:unstructured)
    + roles (nt:unstructured)
        + approvers (nt:unstructured)
             - jcr:title = "Approvers"
             - roleclass = "owner"
             - roleid = "approver"
```
Genom att kopiera mallen Simple Project får du 4 OOTB-arbetsflöden konfigurerade. Varje nod under arbetsflöden/modeller pekar på ett specifikt arbetsflöde och en startdialogruteguide för det arbetsflödet. Senare i den här självstudiekursen skapar vi ett anpassat arbetsflöde för det här projektet. Ta nu bort noderna under arbetsflöde/modeller:
```
../projects/templates/authoring-project
    + gadgets (nt:unstructured)
    + roles (nt:unstructured)
    + workflows (nt:unstructured)
         + models (nt:unstructured)
            - (remove ootb models)
```
För att göra det enkelt för innehållsförfattare att identifiera projektmallen kan du lägga till en anpassad miniatyrbild. Den rekommenderade storleken är 319 x 319 pixlar.
1. Skapa en ny fil på samma nivå som gadgets, roller och arbetsflödesnoder med namnet i CRXDE Lite thumbnail.png.
2. Spara och navigera sedan till jcr:content och dubbelklicka på jcr:data -egenskap (undvik att klicka på "visa").
  1. Detta bör uppmana dig att redigera jcr:data och du kan överföra en egen miniatyrbild.
```
../projects/templates/authoring-project
    + gadgets (nt:unstructured)
    + roles (nt:unstructured)
    + workflows (nt:unstructured)
    + thumbnail.png (nt:file)
```

Slutförd XML-representation av projektmallen:

<?xml version="1.0" encoding="UTF-8"?>
<jcr:root xmlns:sling="http://sling.apache.org/jcr/sling/1.0" xmlns:cq="http://www.day.com/jcr/cq/1.0" xmlns:jcr="http://www.jcp.org/jcr/1.0" xmlns:nt="http://www.jcp.org/jcr/nt/1.0"
    jcr:description="A project to manage approval and publish process for AEM Sites or Assets"
    jcr:primaryType="cq:Template"
    jcr:title="Authoring Project"
    ranking="{Long}1"
    wizard="/libs/cq/core/content/projects/wizard/steps/defaultproject.html">
    <jcr:content
        jcr:primaryType="nt:unstructured"
        detailsHref="/projects/details.html"/>
    <gadgets jcr:primaryType="nt:unstructured">
        <team
            jcr:primaryType="nt:unstructured"
            jcr:title="Team"
            sling:resourceType="cq/gui/components/projects/admin/pod/teampod"
            cardWeight="60"/>
        <tasks
            jcr:primaryType="nt:unstructured"
            jcr:title="Tasks"
            sling:resourceType="cq/gui/components/projects/admin/pod/taskpod"
            cardWeight="100"/>
        <work
            jcr:primaryType="nt:unstructured"
            jcr:title="Workflows"
            sling:resourceType="cq/gui/components/projects/admin/pod/workpod"
            cardWeight="80"/>
        <experiences
            jcr:primaryType="nt:unstructured"
            jcr:title="Experiences"
            sling:resourceType="cq/gui/components/projects/admin/pod/channelpod"
            cardWeight="90"/>
        <projectinfo
            jcr:primaryType="nt:unstructured"
            jcr:title="Project Info"
            sling:resourceType="cq/gui/components/projects/admin/pod/projectinfopod"
            cardWeight="100"/>
    </gadgets>
    <roles jcr:primaryType="nt:unstructured">
        <approvers
            jcr:primaryType="nt:unstructured"
            jcr:title="Approvers"
            roleclass="owner"
            roleid="approvers"/>
    </roles>
    <workflows
        jcr:primaryType="nt:unstructured"
        tags="[]">
        <models jcr:primaryType="nt:unstructured">
        </models>
    </workflows>
</jcr:root>

Testa den anpassade projektmallen

Nu kan vi testa vår projektmall genom att skapa ett nytt projekt.

Du bör se den anpassade mallen som ett av alternativen när du skapar projekt.
När du har valt den anpassade mallen klickar du på Nästa och lägger till dem som en godkännarroll när du fyller i projektmedlemmar.
Klicka på Skapa för att slutföra projektet baserat på den anpassade mallen. På projektkontrollpanelen ser du att aktivitetspanelen och andra paneler som är konfigurerade under gadgets visas automatiskt.

Varför arbetsflöde?

Traditionellt AEM arbetsflöden som bygger på en godkännandeprocess har använt arbetsflödessteg för deltagare. AEM Inkorg innehåller information om uppgifter och arbetsflöden och förbättrad integrering med AEM projekt. De här funktionerna gör det enklare att använda stegen i Skapa uppgift i projekt.

Varför aktiviteter?

Att använda ett steg för att skapa en uppgift framför vanliga deltagarsteg ger några fördelar:

Start- och förfallodatum - gör det enkelt för skribenterna att hantera sin tid, så använder den nya kalenderfunktionen dessa datum.
Prioritet - med inbyggda prioriteringar Låg, Normal och Hög kan författare prioritera arbetet
Kopplade kommentarer - när författarna arbetar med en uppgift kan de lämna kommentarer som ökar samarbetet
Synlighet - Uppgiftsrutor och vyer med projekt gör att chefer kan se hur mycket tid som läggs på
Projektintegrering - Uppgifter är redan integrerade med projektroller och kontrollpaneler

Precis som deltagarsteg kan uppgifter tilldelas och slussas dynamiskt. Metadata för uppgifter som Title, Priority (Prioritet), kan också anges dynamiskt baserat på tidigare åtgärder som vi kommer att se i följande självstudiekurs.

Uppgifter har vissa fördelar jämfört med deltagarsteg, men de har ytterligare omkostnader och är inte lika användbara utanför ett projekt. Dessutom måste alla aktiviteters dynamiska beteende kodas med ecma-skript som har egna begränsningar.

Exempel på krav för användningsfall

Arbetsflödesprocessdiagram

Diagrammet ovan visar de höga kraven för vårt arbetsflöde för provgodkännande.

Det första steget är att skapa en uppgift för att slutföra redigeringen av ett visst innehåll. Vi låter arbetsflödesinitieraren välja den som ska tilldelas den första uppgiften.

När den första uppgiften är klar har den som tilldelats tre alternativ för att dirigera arbetsflödet:

Normal - normal routning skapar en uppgift som tilldelats projektets godkännargrupp för granskning och godkännande. Aktivitetens prioritet är Normal och förfallodatumet är 5 dagar från den dag den skapades.

Rush - Push-routning skapar också en uppgift som är tilldelad projektets godkännargrupp. Aktivitetens prioritet är Hög och förfallodatumet är bara 1 dag.

Kringgå - i det här exempelarbetsflödet kan den initiala deltagaren åsidosätta godkännandegruppen. (ja, detta kan motverka syftet med ett godkännandearbetsflöde, men det gör det möjligt för oss att illustrera ytterligare routningsfunktioner)

Godkännargruppen kan godkänna innehållet eller skicka tillbaka det till den ursprungliga tilldelade personen för omarbete. Om en ny uppgift skickas tillbaka för återarbete skapas den och får den korrekta etiketten"Skickat för återarbete".

I det sista steget i arbetsflödet används steget Aktivera sida/resurs och nyttolasten replikeras.

Skapa arbetsflödesmodellen

Navigera AEM Start-menyn till Verktyg -> Arbetsflöde -> Modeller. Klicka på Skapa i det övre högra hörnet för att skapa en ny arbetsflödesmodell.

Ge den nya modellen en titel: "Arbetsflöde för godkännande av innehåll" och ett URL-namn: "content-approval-workflow".

Mer information om skapa arbetsflöden som läses här.
Som en god vana bör anpassade arbetsflöden grupperas i sin egen mapp under /etc/workflow/models. Skapa ett nytt 'nt:folder' under /etc/workflow/models named "aem-guides". Genom att lägga till en undermapp säkerställer du att anpassade arbetsflöden inte skrivs över av misstag vid uppgraderingar eller Service Pack-installationer.

*Observera att det är viktigt att aldrig placera mappen eller anpassade arbetsflöden under undermappar som /etc/workflow/models/dam eller /etc/workflow/models/projects eftersom hela undermappen också kan skrivas över av uppgraderingar eller servicepaket.

Placering av arbetsflödesmodell i 6.3

OBSERVERA

Om du använder AEM 6.4+ har arbetsflödets plats ändrats. Se här för mer information.

Om AEM 6.4+ används skapas arbetsflödesmodellen under /conf/global/settings/workflow/models. Upprepa stegen ovan med katalogen /conf och lägg till en undermapp med namnet aem-guides och flytta content-approval-workflow under den.

Placering av arbetsflödesmodell i 6.4+
I AEM 6.3 introducerades möjligheten att lägga till arbetsflödessteg i ett visst arbetsflöde. Stegen visas för användaren från Inkorgen på fliken Arbetsflödesinformation. Den visar användaren det aktuella steget i arbetsflödet samt de steg som föregår och följer det.

Om du vill konfigurera faserna öppnar du dialogrutan Sidegenskaper från SideKick. Den fjärde fliken heter "Steg". Lägg till följande värden för att konfigurera de tre stegen i det här arbetsflödet:
1. Redigera innehåll
2. Godkännande
3. Publicera
Konfigurera arbetsflödesstegen i dialogrutan Sidegenskaper.

Förloppsindikatorn för arbetsflödet som visas i AEM Inkorg.

Du kan också ladda upp en Bild till Sidegenskaper som används som arbetsflödesminiatyrbild när användare markerar den. Bilddimensionerna ska vara 319 x 319 pixlar. Lägga till en Beskrivning i Sidegenskaper visas också när en användare väljer arbetsflödet.
Arbetsflödet Skapa projektuppgift är utformat för att skapa en uppgift som ett steg i arbetsflödet. Arbetsflödet går framåt först när uppgiften har slutförts. En kraftfull aspekt av steget Skapa projektuppgift är att det går att läsa metadatavärden för arbetsflödet och använda dem för att dynamiskt skapa uppgiften.

Ta först bort det deltagarsteg som skapas som standard. Från Sidekick på komponentmenyn expanderar du "Projekt" underrubrik och dra och släpp "Skapa projektuppgift" på modellen.

Dubbelklicka på steget"Skapa projektuppgift" för att öppna arbetsflödesdialogrutan. Konfigurera följande egenskaper:

Den här fliken är vanlig för alla steg i arbetsflödet och vi ställer in titeln och beskrivningen (de visas inte för slutanvändaren). Den viktiga egenskap som vi ställer in är arbetsflödessteget "Redigera innehåll" i listrutan.
```
Common Tab
-----------------
    Title = "Start Task Creation"
    Description = "This the first task in the Workflow"
    Workflow Stage = "Edit Content"
```
Arbetsflödet Skapa projektuppgift är utformat för att skapa en uppgift som ett steg i arbetsflödet. På fliken Uppgift kan vi ange alla värden för uppgiften. I vårt fall vill vi att den som ska tilldelas ska vara dynamisk så att den lämnas tom. Resten av egenskapsvärdena:
```
Task Tab
-----------------
    Name* = "Edit Content"
    Task Priority = "Medium"
    Description = "Edit the content and finalize for approval. Once finished submit for approval."
    Due In - Days = "2"
```
Fliken för routning är en valfri dialogruta som kan ange tillgängliga åtgärder för användaren som utför uppgiften. Dessa åtgärder är bara strängvärden och sparas i arbetsflödets metadata. Dessa värden kan läsas av skript och/eller processteg senare i arbetsflödet för att dynamiskt dirigera arbetsflödet. Baserat på arbetsflödesmål ska vi lägga till tre åtgärder på den här fliken:
```
Routing Tab
-----------------
    Actions =
        "Normal Approval"
        "Rush Approval"
        "Bypass Approval"
```
På den här fliken kan vi konfigurera ett fördefinierat uppgiftsskript, där vi programmässigt kan bestämma olika värden för uppgiften innan den skapas. Vi kan välja att peka skriptet mot en extern fil eller bädda in ett kort skript direkt i dialogrutan. I det här fallet pekar vi på Skriptet för förskapande av uppgift mot en extern fil. I steg 5 ska vi skapa det skriptet.
```
Advanced Settings Tab
-----------------
   Pre-Create Task Script = "/apps/aem-guides/projects/scripts/start-task-config.ecma"
```
I föregående steg refererade vi till ett Pre-Create Task Script. Vi ska skapa skriptet där vi nu ställer in Tilldelning av uppgiften baserat på värdet för arbetsflödets metadatavärde tilldelad". The ’tilldelad’ värdet anges när arbetsflödet startas. Vi läser också arbetsflödets metadata för att dynamiskt välja uppgiftens prioritet genom att läsa "taskPriority" värdet på arbetsflödets metadata samt "taskdueDate"  som dynamiskt anges när den första uppgiften förfaller.

För organisatoriska ändamål har vi skapat en mapp under vår appmapp för alla våra projektrelaterade skript: /apps/aem-guides/projects-tasks/projects/scripts. Skapa en ny fil med namnet under den här mappen "start-task-config.ecma". *Observera att sökvägen till filen start-task-config.ecma matchar sökvägen som angetts på fliken Avancerade inställningar i steg 4.

Lägg till följande som innehåll i filen:
```
// start-task-config.ecma
// Populate the task using values stored as workflow metadata originally posted by the start workflow wizard

// set the assignee based on start workflow wizard
var assignee = workflowData.getMetaDataMap().get("assignee", Packages.java.lang.String);
task.setCurrentAssignee(assignee);

//Set the due date for the initial task based on start workflow wizard
var dueDate = workflowData.getMetaDataMap().get("taskDueDate", Packages.java.util.Date);
if (dueDate != null) {
    task.setProperty("taskDueDate", dueDate);
}

//Set the priority based on start workflow wizard
var taskPriority = workflowData.getMetaDataMap().get("taskPriority", "Medium");
task.setProperty("taskPriority", taskPriority);
```
Gå tillbaka till arbetsflödet för godkännande av innehåll. Dra och släpp ELLER Dela -komponenten (finns i Sidespark under kategorin 'Arbetsflöde') under Starta aktivitet Steg. I dialogrutan Allmänt väljer du alternativknappen för 3 grenar. OR-delningen läser arbetsflödets metadatavärde "lastTaskAction" för att fastställa arbetsflödets väg. The "lastTaskAction" egenskapen är inställd på ett av värdena från fliken Routning som konfigurerats i steg 4. För var och en av förgreningsflikarna fyller du i Skript textområde med följande värden:
```
function check() {
var lastAction = workflowData.getMetaDataMap().get("lastTaskAction","");

if(lastAction == "Normal Approval") {
    return true;
}

return false;
}
```
```
function check() {
var lastAction = workflowData.getMetaDataMap().get("lastTaskAction","");

if(lastAction == "Rush Approval") {
    return true;
}

return false;
}
```
```
function check() {
var lastAction = workflowData.getMetaDataMap().get("lastTaskAction","");

if(lastAction == "Bypass Approval") {
    return true;
}

return false;
}
```
*Observera att vi gör en direkt strängmatchning för att fastställa vägen, så det är viktigt att värdena som anges i grenskripten matchar de flödesvärden som anges i steg 4.
Dra och släpp en annan "Skapa projektuppgift" steg vidare till modellen längst till vänster (grenen 1) under ELLER-delningen. Fyll i dialogrutan med följande egenskaper:
```
Common Tab
-----------------
    Title = "Approval Task Creation"
    Description = "Create a an approval task for Project Approvers. Priority is Medium."
    Workflow Stage = "Approval"

Task Tab
------------
    Name* = "Approve Content for Publish"
    Task Priority = "Medium"
    Description = "Approve this content for publication."
    Days = "5"

Routing Tab - Actions
----------------------------
    "Approve and Publish"
    "Send Back for Revision"
```
Eftersom det här är den normala vägen för godkännande anges aktivitetens prioritet till Medel. Dessutom ger vi gruppen Godkännare 5 dagar på oss att slutföra uppgiften. Den som ska tilldelas är tom på fliken Aktivitet eftersom den tilldelas dynamiskt på fliken Avancerade inställningar. Vi ger gruppen Godkännare två möjliga vägar när vi slutför den här uppgiften: "Godkänn och publicera" om de godkänner innehållet och det kan publiceras och "Tillbaka för revision" om det finns problem som den ursprungliga redigeraren behöver korrigera. Godkännaren kan lämna kommentarer som den ursprungliga redigeraren ser om arbetsflödet returneras till honom/henne.

Tidigare i den här självstudiekursen skapade vi en projektmall som innehöll en godkännarroll. Varje gång ett nytt projekt skapas från den här mallen skapas en projektspecifik grupp för rollen Godkännare. På samma sätt som ett deltagarsteg kan en uppgift bara tilldelas till en användare eller grupp. Vi vill tilldela den här uppgiften till den projektgrupp som motsvarar gruppen Godkännare. Alla arbetsflöden som startas från ett projekt har metadata som mappar projektrollerna till den projektspecifika gruppen.

Kopiera+Klistra in följande kod i Skript textområdet på fliken Avancerade inställningar . Den här koden läser arbetsflödets metadata och tilldelar uppgiften till gruppen Godkännare för projektet. Om det inte går att hitta värdet för gruppen godkännare återgår det till att tilldela uppgiften till gruppen Administratörer.

var projectApproverGrp = workflowData.getMetaDataMap().get("project.group.approvers","administrators");

task.setCurrentAssignee(projectApproverGrp);

Dra och släpp en annan "Skapa projektuppgift" steg vidare till modellen till den mittersta grenen (grenen 2) under ELLER-delningen. Fyll i dialogrutan med följande egenskaper:
```
Common Tab
-----------------
    Title = "Rush Approval Task Creation"
    Description = "Create a an approval task for Project Approvers. Priority is High."
    Workflow Stage = "Approval"

Task Tab
------------
    Name* = "Rush Approve Content for Publish"
    Task Priority = "High"
    Description = "Rush approve this content for publication."
    Days = "1"

Routing Tab - Actions
----------------------------
    "Approve and Publish"
    "Send Back for Revision"
```
Eftersom det här är vägen för Rush-godkännande är aktivitetens prioritet inställd på Hög. Dessutom ger vi gruppen Godkännare endast en dag för att slutföra uppgiften. Den som ska tilldelas är tom på fliken Aktivitet eftersom den tilldelas dynamiskt på fliken Avancerade inställningar.

Vi kan återanvända samma skriptfragment som i steg 7 för att fylla i Skript textområdet på fliken  Avancerade inställningar  tfliken. Kopiera+Klistra in nedanstående kod:
```
var projectApproverGrp = workflowData.getMetaDataMap().get("project.group.approvers","administrators");

task.setCurrentAssignee(projectApproverGrp);
```
Dra och släpp en  Ingen åtgärd-komponent längst till höger (grenen 3). Komponenten Ingen åtgärd utför ingen åtgärd och kommer att fortsätta omedelbart, vilket motsvarar den ursprungliga redigerarens önskan att kringgå godkännandesteget. Tekniskt sett kan vi lämna den här grenen utan några arbetsflödessteg, men som en bra rutin lägger vi till steget Ingen åtgärd. Detta gör det klart för andra utvecklare vad syftet med gren 3 är.

Dubbelklicka på arbetsflödessteget och konfigurera rubriken och beskrivningen:
```
Common Tab
-----------------
    Title = "Bypass Approval"
    Description = "Placeholder step to indicate that the original editor decided to bypass the approver group."
```
Arbetsflödesmodellen ska se ut så här när alla tre grenarna i ELLER-delningen har konfigurerats.
Eftersom gruppen Godkännare har möjlighet att skicka tillbaka arbetsflödet till den ursprungliga redigeraren för ytterligare ändringar, använder vi Gå om du vill läsa den senaste åtgärden och dirigera arbetsflödet till början eller låta det fortsätta.

Dra och släpp Goto Step-komponenten (finns i sidosparken under Arbetsflöde) under ELLER-delningen där den återansluter. Dubbelklicka på och konfigurera följande egenskaper i dialogrutan:
```
Common Tab
----------------
    Title = "Goto Step"
    Description = "Based on the Approver groups action route the workflow to the beginning or continue and publish the payload."

Process Tab
---------------
    The step to go to. = "Start Task Creation"
```
Den sista delen som vi ska konfigurera är skriptet som en del av Gå till-processsteget. Skriptvärdet kan bäddas in via dialogrutan eller konfigureras så att det pekar på en extern fil. Goto-skriptet måste innehålla en function check() och returnerar true om arbetsflödet ska gå till det angivna steget. Om du returnerar false flyttas arbetsflödet framåt.

Om godkännargruppen väljer "Tillbaka för revision" (konfigurerad i steg 7 och 8) vill vi returnera arbetsflödet till "Starta skapande av aktivitet" steg.

På fliken Process lägger du till följande utdrag i skripttextområdet:
```
function check() {
var lastAction = workflowData.getMetaDataMap().get("lastTaskAction","");

if(lastAction == "Send Back for Revision") {
    return true;
}

return false;
}
```
För att publicera nyttolasten använder vi verktygsfältet Aktivera sida/resurs Bearbeta steg. Det här steget kräver liten konfiguration och lägger till arbetsflödets nyttolast i replikeringskön för aktivering. Vi lägger till steget under steget Gå till och på det här sättet kan det bara nås om gruppen Godkännare har godkänt innehållet för publicering eller om den ursprungliga redigeraren har valt vägen Åsidosätt godkännande.

Dra och släpp Aktivera sida/resurs Bearbeta steg (finns i Sidekick under WCM-arbetsflöde) under Gå till steg i modellen.

Hur arbetsflödesmodellen ska se ut när du har lagt till steget Gå till och Aktivera sidan/resursen.

Om gruppen Godkännare skickar tillbaka innehållet för revision vill vi meddela den ursprungliga redigeraren. Vi kan uppnå detta genom att dynamiskt ändra egenskaperna för att skapa uppgifter. Egenskapsvärdet lastActionTaken för "Tillbaka för revision". Om det värdet finns ändrar vi titeln och beskrivningen för att ange att den här uppgiften är resultatet av att innehållet skickas tillbaka för revision. Vi kommer även att uppdatera prioriteten till "Hög" så att det blir det första objektet som redigeraren arbetar med. Slutligen ställer vi in aktivitetens förfallodatum till en dag från när arbetsflödet skickades tillbaka för revision.

Ersätt start start-task-config.ecma skript (skapat i steg 5) med följande:

// start-task-config.ecma
// Populate the task using values stored as workflow metadata originally posted by the start workflow wizard

// set the assignee based on start workflow wizard
var assignee = workflowData.getMetaDataMap().get("assignee", Packages.java.lang.String);
task.setCurrentAssignee(assignee);

//Set the due date for the initial task based on start workflow wizard
var dueDate = workflowData.getMetaDataMap().get("taskDueDate", Packages.java.util.Date);
if (dueDate != null) {
    task.setProperty("taskDueDate", dueDate);
}

//Set the priority based on start workflow wizard
var taskPriority = workflowData.getMetaDataMap().get("taskPriority", "Medium");
task.setProperty("taskPriority", taskPriority);

var lastAction = workflowData.getMetaDataMap().get("lastTaskAction","");

//change the title and priority if the approver group sent back the content
if(lastAction == "Send Back for Revision") {
  var taskName = "Review and Revise Content";

  //since the content was rejected we will set the priority to High for the revison task
  task.setProperty("taskPriority", "High");

  //set the Task name (displayed as the task title in the Inbox)
  task.setProperty("name", taskName);
  task.setProperty("nameHierarchy", taskName);

  //set the due date of this task 1 day from current date
  var calDueDate = Packages.java.util.Calendar.getInstance();
  calDueDate.add(Packages.java.util.Calendar.DATE, 1);
  task.setProperty("taskDueDate", calDueDate.getTime());

}

Skapa guiden Starta arbetsflöde

När du stänger av ett arbetsflöde inifrån ett projekt måste du ange en guide för att starta arbetsflödet. Standardguiden: /libs/cq/core/content/projects/workflowwizards/default_workflow gör att användaren kan ange en arbetsflödesrubrik, en startkommentar och en nyttolastsökväg som arbetsflödet ska köras i. Det finns också flera andra exempel i: /libs/cq/core/content/projects/workflowwizards.

Att skapa en anpassad guide kan vara mycket kraftfullt eftersom du kan samla in viktig information innan arbetsflödet startar. Data lagras som en del av arbetsflödets metadata och arbetsflödesprocesser kan läsa detta och dynamiskt ändra beteendet baserat på de värden som anges. Vi skapar en anpassad guide som dynamiskt tilldelar den första uppgiften i arbetsflödet baserat på ett startguidevärde.

I CRXDE-Lite skapar vi en undermapp under /apps/aem-guides/projects-tasks/projects mappen "wizards". Kopiera standardguiden från: /libs/cq/core/content/projects/workflowwizards/default_workflow under den nya guidemappen och ge den ett nytt namn content-approval-start. Den fullständiga sökvägen bör nu vara: /apps/aem-guides/projects-tasks/projects/wizards/content-approval-start.

Standardguiden är en guide med två kolumner där den första kolumnen med rubrik, beskrivning och miniatyrbild för arbetsflödesmodellen är vald. Den andra kolumnen innehåller fält för arbetsflödets titel, Start Comment och Payload Path. Guiden är ett vanligt Touch-användargränssnittsformulär och använder standardformatet Gränssnittskomponenter för Granite för att fylla i fälten.
Vi ska lägga till ytterligare ett fält i guiden som används för att ange den som ska tilldelas den första uppgiften i arbetsflödet (se Skapa arbetsflödesmodellen: Steg 5).

Under ../content-approval-start/jcr:content/items/column2/items skapa en ny nod av typen nt:unstructured namngiven "assign". Vi kommer att använda komponenten Projects User Picker (som är baserad på Bevilja användarväljarkomponent). Det här formulärfältet gör det enkelt att begränsa användar- och gruppmarkeringen till endast de som tillhör det aktuella projektet.

Nedan visas XML-representationen av tilldela nod:
```
<assign
    granite:class="js-cq-project-user-picker"
    jcr:primaryType="nt:unstructured"
    sling:resourceType="cq/gui/components/projects/admin/userpicker"
    fieldLabel="Assign To"
    hideServiceUsers="{Boolean}true"
    impersonatesOnly="{Boolean}true"
    showOnlyProjectMembers="{Boolean}true"
    name="assignee"
    projectPath="${param.project}"
    required="{Boolean}true"/>
```
Vi ska också lägga till ett prioritetsurvalsfält som avgör prioriteten för den första uppgiften i arbetsflödet (se Skapa arbetsflödesmodellen: Steg 5).

Under /content-approval-start/jcr:content/items/column2/items skapa en ny nod av typen nt:unstructured namngiven prioritet. Vi använder Komponenten för val av användargränssnitt för att fylla i formulärfältet.

Under prioritet nod som vi ska lägga till objekt nod på nt:ostrukturerad. Under objekt noden lägger till ytterligare 3 noder för att fylla i markeringsalternativen Hög, Medel och Låg. Varje nod är av typen nt:ostrukturerad och bör ha en text och value -egenskap. Både texten och värdet ska ha samma värde:
1. Hög
2. Medel
3. Låg
För noden Medium lägger du till ytterligare en boolesk egenskap med namnet "selected" med ett värde inställt på true. Detta garanterar att Medium är standardvärdet i markeringsfältet.

Nedan visas en XML-representation av nodstrukturen och -egenskaperna:
```
<priority
    jcr:primaryType="nt:unstructured"
    sling:resourceType="granite/ui/components/coral/foundation/form/select"
    fieldLabel="Task Priority"
    name="taskPriority">
        <items jcr:primaryType="nt:unstructured">
            <high
                jcr:primaryType="nt:unstructured"
                text="High"
                value="High"/>
            <medium
                jcr:primaryType="nt:unstructured"
                selected="{Boolean}true"
                text="Medium"
                value="Medium"/>
            <low
                jcr:primaryType="nt:unstructured"
                text="Low"
                value="Low"/>
            </items>
</priority>
```

Vi tillåter att arbetsflödesinitieraren anger förfallodatumet för den första uppgiften. Vi använder Granite UI DatePicker formulärfält för att hämta indata. Vi lägger också till ett dolt fält med en TypeHint för att se till att indata lagras som en Date-typegenskap i JCR.

Lägg till två nt:ostrukturerad noder med följande egenskaper representerade nedan i XML:

<duedate
    granite:rel="project-duedate"
    jcr:primaryType="nt:unstructured"
    sling:resourceType="granite/ui/components/coral/foundation/form/datepicker"
    displayedFormat="YYYY-MM-DD HH:mm"
    fieldLabel="Due Date"
    minDate="today"
    name="taskDueDate"
    type="datetime"/>
<duedatetypehint
    jcr:primaryType="nt:unstructured"
    sling:resourceType="granite/ui/components/coral/foundation/form/hidden"
    name="taskDueDate@TypeHint"
    type="datetime"
    value="Calendar"/>

Du kan visa den fullständiga koden för startguiden här.

Ansluta arbetsflödet och projektmallen

Det sista vi behöver göra är att se till att arbetsflödesmodellen är tillgänglig att startas från i något av projekten. För att göra detta måste vi besöka projektmallen som vi skapade i del 1 i den här serien igen.

Arbetsflödeskonfigurationen är ett område i en projektmall som anger vilka arbetsflöden som är tillgängliga för projektet. Konfigurationen ansvarar också för att ange guiden Starta arbetsflöde när arbetsflödet startas (som vi skapade i föregående steg). Arbetsflödeskonfigurationen för en projektmall är"live", vilket innebär att om du uppdaterar arbetsflödeskonfigurationen kommer både nya projekt som skapats och befintliga projekt som använder mallen att påverkas.

I CRXDE-Lite navigerar du till den projektmall som skapades tidigare på /apps/aem-guides/projects-tasks/projects/templates/authoring-project/workflows/models.

Under modellnoden lägger du till en ny nod med namnet innehållgodkännande med en nodtyp av nt:ostrukturerad. Lägg till följande egenskaper i noden:
```
<contentapproval
    jcr:primaryType="nt:unstructured"
    modelId="/etc/workflow/models/aem-guides/content-approval-workflow/jcr:content/model"
    wizard="/apps/aem-guides/projects-tasks/projects/wizards/content-approval-start.html"
/>
```
OBSERVERA

Om AEM 6.4 används har arbetsflödets plats ändrats. Peka på modelId egenskapen till platsen för körningsarbetsflödesmodellen under /var/workflow/models/aem-guides/content-approval-workflow

Se här finns mer information om förändringen i arbetsflödets plats.
```
<contentapproval
    jcr:primaryType="nt:unstructured"
    modelId="/var/workflow/models/aem-guides/content-approval-workflow"
    wizard="/apps/aem-guides/projects-tasks/projects/wizards/content-approval-start.html"
/>
```
När arbetsflödet för godkännande av innehåll har lagts till i projektmallen bör det vara tillgängligt att starta från projektets arbetsflödespanel. Starta och lek med de olika routningar vi har skapat.

Stödmaterial

Föregående sida

Utveckla projekt i AEM

Introduktion

Inställningar

Struktur för en projektmall

Projektmallsrot

Gadgets

Roller

Arbetsflöden

Skapa en projektmall

Testa den anpassade projektmallen

Varför arbetsflöde?

Varför aktiviteter?

Exempel på krav för användningsfall

Skapa arbetsflödesmodellen

Skapa guiden Starta arbetsflöde

Ansluta arbetsflödet och projektmallen

Stödmaterial

På denna sida

Visa nästa:

Lär

Dokumentation

Community

Support

Resurser

Adobe-konto

Adobe