AEM Workflows#

package com.myproject.core.workflow;

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.WorkflowProcess;
import com.adobe.granite.workflow.metadata.MetaDataMap;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ModifiableValueMap;
import org.osgi.service.component.annotations.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component(
    service = WorkflowProcess.class,
    property = {
        "process.label=My Project - Auto Tag Pages"
    }
)
public class AutoTagProcessStep implements WorkflowProcess {

    private static final Logger LOG = LoggerFactory.getLogger(AutoTagProcessStep.class);

    @Override
    public void execute(WorkItem workItem, WorkflowSession workflowSession,
                        MetaDataMap metaDataMap) throws WorkflowException {

        // 1. Get the payload path
        String payloadPath = workItem.getWorkflowData().getPayload().toString();
        LOG.info("Processing payload: {}", payloadPath);

        // 2. Read process step arguments (configured in the workflow model editor)
        String tagNamespace = metaDataMap.get("PROCESS_ARGS", "myproject:");

        // 3. Access the JCR via the workflow session's resource resolver
        ResourceResolver resolver = workflowSession.adaptTo(ResourceResolver.class);
        if (resolver == null) {
            throw new WorkflowException("Could not obtain ResourceResolver");
        }

        Resource contentResource = resolver.getResource(payloadPath + "/jcr:content");
        if (contentResource == null) {
            LOG.warn("No jcr:content found at {}", payloadPath);
            return;
        }

        // 4. Apply business logic
        ModifiableValueMap properties = contentResource.adaptTo(ModifiableValueMap.class);
        if (properties != null) {
            String title = properties.get("jcr:title", "");
            // Example: auto-tag based on title keywords
            if (title.toLowerCase().contains("news")) {
                String[] existingTags = properties.get("cq:tags", new String[0]);
                String newTag = tagNamespace + "content-type/news";
                if (!java.util.Arrays.asList(existingTags).contains(newTag)) {
                    String[] updatedTags = java.util.Arrays.copyOf(
                        existingTags, existingTags.length + 1);
                    updatedTags[existingTags.length] = newTag;
                    properties.put("cq:tags", updatedTags);
                    LOG.info("Tagged {} with {}", payloadPath, newTag);
                }
            }
            resolver.commit();
        }
    }
}

// Get the raw payload (usually a String path)
String payloadPath = workItem.getWorkflowData().getPayload().toString();

// Get the payload type
String payloadType = workItem.getWorkflowData().getPayloadType();
// Common values: "JCR_PATH", "JCR_UUID", "URL"

// Adapt to a resource
ResourceResolver resolver = workflowSession.adaptTo(ResourceResolver.class);
Resource resource = resolver.getResource(payloadPath);

// Adapt to a Page
PageManager pageManager = resolver.adaptTo(PageManager.class);
Page page = pageManager.getPage(payloadPath);

// Adapt to an Asset
Asset asset = resource.adaptTo(Asset.class);

package com.myproject.core.workflow;

import com.adobe.granite.workflow.WorkflowException;
import com.adobe.granite.workflow.WorkflowSession;
import com.adobe.granite.workflow.exec.ParticipantStepChooser;
import com.adobe.granite.workflow.exec.WorkItem;
import com.adobe.granite.workflow.metadata.MetaDataMap;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ValueMap;
import org.osgi.service.component.annotations.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component(
    service = ParticipantStepChooser.class,
    property = {
        "chooser.label=My Project - Content Owner Chooser"
    }
)
public class ContentOwnerChooser implements ParticipantStepChooser {

    private static final Logger LOG = LoggerFactory.getLogger(ContentOwnerChooser.class);
    private static final String DEFAULT_GROUP = "content-authors";

    @Override
    public String getParticipant(WorkItem workItem, WorkflowSession workflowSession,
                                  MetaDataMap metaDataMap) throws WorkflowException {

        String payloadPath = workItem.getWorkflowData().getPayload().toString();
        ResourceResolver resolver = workflowSession.adaptTo(ResourceResolver.class);

        if (resolver != null) {
            Resource jcrContent = resolver.getResource(payloadPath + "/jcr:content");
            if (jcrContent != null) {
                ValueMap props = jcrContent.getValueMap();
                // Route to the page's designated reviewer if set
                String reviewer = props.get("reviewer", String.class);
                if (reviewer != null && !reviewer.isEmpty()) {
                    LOG.info("Routing {} to designated reviewer: {}", payloadPath, reviewer);
                    return reviewer;
                }
            }
        }

        // Fallback to a default group
        LOG.info("No designated reviewer for {}, routing to {}", payloadPath, DEFAULT_GROUP);
        return DEFAULT_GROUP;
    }
}

package com.myproject.core.workflow;

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.WorkflowProcess;
import com.adobe.granite.workflow.exec.WorkflowData;
import com.adobe.granite.workflow.metadata.MetaDataMap;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ValueMap;
import org.osgi.service.component.annotations.Component;

@Component(
    service = WorkflowProcess.class,
    property = {
        "process.label=My Project - Set Publish Ready Flag"
    }
)
public class PublishReadyCheckStep implements WorkflowProcess {

    @Override
    public void execute(WorkItem workItem, WorkflowSession session, MetaDataMap args)
            throws WorkflowException {

        WorkflowData workflowData = workItem.getWorkflowData();
        Object payload = workflowData != null ? workflowData.getPayload() : null;
        if (payload == null || !"JCR_PATH".equals(workflowData.getPayloadType())) {
            throw new WorkflowException("Expected a JCR_PATH payload");
        }
        String payloadPath = payload.toString();

        ResourceResolver resolver = session.adaptTo(ResourceResolver.class);
        if (resolver == null) {
            throw new WorkflowException("Could not obtain ResourceResolver");
        }

        Resource jcrContent = resolver.getResource(payloadPath + "/jcr:content");
        boolean publishReady = false;
        if (jcrContent != null) {
            ValueMap props = jcrContent.getValueMap();
            publishReady = props.containsKey("jcr:title")
                && props.containsKey("jcr:description")
                && props.containsKey("featuredImage");
        }

        // Store the result so the OR Split branches can read it
        workItem.getWorkflow().getWorkflowData().getMetaDataMap()
            .put("publishReady", publishReady);
    }
}

@Reference
private com.adobe.granite.workflow.WorkflowService workflowService;

public void startApprovalWorkflow(ResourceResolver resolver, String pagePath)
        throws WorkflowException {

    WorkflowSession wfSession = workflowService.getWorkflowSession(
        resolver.adaptTo(Session.class));

    // Load the workflow model
    WorkflowModel model = wfSession.getModel("/var/workflow/models/request_for_activation");

    // Create the workflow data (payload)
    WorkflowData data = wfSession.newWorkflowData("JCR_PATH", pagePath);

    // Optionally add metadata
    data.getMetaDataMap().put("comment", "Submitted for review");
    data.getMetaDataMap().put("urgency", "high");

    // Start the workflow
    wfSession.startWorkflow(model, data);
}

public List<String> getRunningWorkflowIds(ResourceResolver resolver) throws WorkflowException {
    WorkflowSession wfSession = resolver.adaptTo(WorkflowSession.class);
    Workflow[] allWorkflows = wfSession.getAllWorkflows();

    List<String> runningIds = new ArrayList<>();
    for (Workflow wf : allWorkflows) {
        if ("RUNNING".equals(wf.getState())) {
            runningIds.add(wf.getId());
        }
    }
    return runningIds;
}

/**
 * Terminates all running workflow instances visible to the given resolver.
 * Use with caution - this is typically an admin operation.
 */
public int terminateAllRunningWorkflows(ResourceResolver resolver) {
    WorkflowSession workflowSession = resolver.adaptTo(WorkflowSession.class);
    if (workflowSession == null) {
        LOG.error("Could not obtain WorkflowSession");
        return 0;
    }

    int terminated = 0;
    try {
        Workflow[] allWorkflows = workflowSession.getAllWorkflows();
        for (Workflow wf : allWorkflows) {
            if ("RUNNING".equals(wf.getState())) {
                String id = wf.getId();
                try {
                    workflowSession.terminateWorkflow(wf);
                    terminated++;
                    LOG.info("Terminated workflow: {}", id);
                } catch (WorkflowException e) {
                    LOG.error("Could not terminate workflow {}", id, e);
                }
            }
        }
    } catch (WorkflowException e) {
        LOG.error("Error retrieving workflows", e);
    }
    return terminated;
}

/**
 * Disables all workflow launchers. Useful during bulk imports or migrations
 * to prevent unwanted workflow triggers.
 */
public void disableAllLaunchers(ResourceResolver resolver) throws LoginException {
    WorkflowLauncher launcherService = resolver.adaptTo(WorkflowLauncher.class);
    if (launcherService == null) {
        LOG.error("Could not obtain WorkflowLauncher service");
        return;
    }

    Iterator<ConfigEntry> entries = launcherService.getConfigEntries();
    while (entries.hasNext()) {
        ConfigEntry entry = entries.next();
        if (entry.isEnabled()) {
            entry.setEnabled(false);
            LOG.info("Disabled launcher: {}", entry.getId());
        }
    }
}

/**
 * Re-enables all workflow launchers.
 */
public void enableAllLaunchers(ResourceResolver resolver) {
    WorkflowLauncher launcherService = resolver.adaptTo(WorkflowLauncher.class);
    if (launcherService == null) return;

    Iterator<ConfigEntry> entries = launcherService.getConfigEntries();
    while (entries.hasNext()) {
        ConfigEntry entry = entries.next();
        if (!entry.isEnabled()) {
            entry.setEnabled(true);
            LOG.info("Enabled launcher: {}", entry.getId());
        }
    }
}

@Component(
    service = WorkflowProcess.class,
    property = {
        "process.label=My Project - Add Watermark Rendition"
    }
)
public class WatermarkRenditionStep implements WorkflowProcess {

    @Override
    public void execute(WorkItem workItem, WorkflowSession workflowSession,
                        MetaDataMap metaDataMap) throws WorkflowException {

        String payloadPath = workItem.getWorkflowData().getPayload().toString();
        ResourceResolver resolver = workflowSession.adaptTo(ResourceResolver.class);
        Resource assetResource = resolver.getResource(payloadPath);

        if (assetResource == null) return;

        Asset asset = assetResource.adaptTo(Asset.class);
        if (asset == null) return;

        // Get the original rendition
        Rendition original = asset.getOriginal();
        if (original == null) return;

        // Example: create a watermarked rendition
        // (actual image processing code omitted for brevity)
        try (InputStream watermarked = applyWatermark(original.getStream())) {
            asset.addRendition("cq5dam.watermark.png", watermarked, "image/png");
            resolver.commit();
        } catch (Exception e) {
            throw new WorkflowException("Watermark generation failed", e);
        }
    }

    private InputStream applyWatermark(InputStream original) {
        // Image processing logic using Java2D, ImageMagick, etc.
        return original; // placeholder
    }
}

@Reference
private ResourceResolverFactory resolverFactory;

private ResourceResolver getServiceResolver() throws LoginException {
    Map<String, Object> params = new HashMap<>();
    params.put(ResourceResolverFactory.SUBSERVICE, "workflow-service");
    return resolverFactory.getServiceResourceResolver(params);
}

@ExtendWith(AemContextExtension.class)
class AutoTagProcessStepTest {

    private final AemContext context = new AemContext();

    @Test
    void shouldTagNewsPages() throws WorkflowException {
        // Setup
        context.create().page("/content/test", "/conf/template",
            Map.of("jcr:title", "Breaking News Today"));

        WorkItem workItem = mock(WorkItem.class);
        WorkflowData workflowData = mock(WorkflowData.class);
        when(workItem.getWorkflowData()).thenReturn(workflowData);
        when(workflowData.getPayload()).thenReturn("/content/test");

        WorkflowSession wfSession = mock(WorkflowSession.class);
        when(wfSession.adaptTo(ResourceResolver.class))
            .thenReturn(context.resourceResolver());

        MetaDataMap metaData = new SimpleMetaDataMap();
        metaData.put("PROCESS_ARGS", "myproject:");

        // Execute
        AutoTagProcessStep step = new AutoTagProcessStep();
        step.execute(workItem, wfSession, metaData);

        // Verify
        Resource jcrContent = context.resourceResolver()
            .getResource("/content/test/jcr:content");
        String[] tags = jcrContent.getValueMap().get("cq:tags", new String[0]);
        assertTrue(Arrays.asList(tags).contains("myproject:content-type/news"));
    }
}